params_checker 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0013a86614eb2a40c8e5d526ebba0cdd244367c32e86812f388059e26abaf952
+  data.tar.gz: 675209c8ae0ac1ba49bffd934afa6bb34a66e7c02e107cfbd0718336f362534c
+SHA512:
+  metadata.gz: a83330c3e167398a9d90773f568d9666fd4c63fefcae418d3767fc9c868952f09de975435a456ae5a3f7f6c3371a772a2feb64dc3181a3301d119b84fc13260d
+  data.tar.gz: 797e848185371dc8ca275b47fe0d2c92ac8bd1ac05179b1a772eff6b3e3ca7f9145c7dc8b44e294a6d9d897927004f3cb0968465c30ef57877f6269c2e9416d6

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# ParamsChecker
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'params_checker'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem 'params_checker', git: 'git@gitlab.com:rexylab/params-checker.git', branch: 'development'
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ParamsChecker'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/params_checker_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/params_checker .css

data/app/assets/stylesheets/params_checker/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/params_checker/application_controller.rb

@@ -0,0 +1,5 @@
+module ParamsChecker
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/helpers/params_checker/application_helper.rb

@@ -0,0 +1,4 @@
+module ParamsChecker
+  module ApplicationHelper
+  end
+end

data/app/jobs/params_checker/application_job.rb

@@ -0,0 +1,4 @@
+module ParamsChecker
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/params_checker/application_mailer.rb

@@ -0,0 +1,6 @@
+module ParamsChecker
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/params_checker/application_record.rb

@@ -0,0 +1,5 @@
+module ParamsChecker
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/params_checker/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Params checker</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "params_checker/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+ParamsChecker::Engine.routes.draw do
+end

data/lib/params_checker/base_params_checker.rb

@@ -0,0 +1,247 @@
+module ParamsChecker
+  class BaseParamsChecker
+    include Fields
+    prepend SimpleCommand
+    def initialize(params: {}, context: {}, is_outest_hash: true)
+      @params = params
+      @context = context
+      @is_outest_hash = is_outest_hash
+      @formatted_params_after_default_check = {}
+      @formatted_params_after_custom_specify_field_checks = {}
+      @formatted_params_after_custom_all_fields_check = {}
+    end
+
+    def self.init required: true, many: false, allow_empty: false
+      raise "This field's type must be boolean." if [required, many, allow_empty].any? { |value| !value.in? [true, false] }
+
+      type = many ? 'nested_hashs' : 'nested_hash'
+      {
+          type: type,
+          required: required,
+          many: many,
+          allow_empty: allow_empty,
+          class: self
+      }
+    end
+
+    def raise_error message="Invalid data"
+      raise MyError.new(message)
+    end
+
+    def call
+      default_check && custom_check
+      error_exist? && add_error
+      formatted_params
+    rescue => e
+      # only add errors at the first hash, else raise error for the first hash to catch
+      # example:
+      # old:
+      # {
+      #   "errors": {
+      #     "message": "Invalid data",
+      #     "details": {
+      #       "purchase_order_items": [
+      #         {
+      #           "errors": {
+      #             "message": "Material not exists.",
+      #             "details": {}
+      #           }
+      #         }
+      #       ]
+      #     }
+      #   }
+      # }
+      # new: 
+      # {
+      #   "errors": {
+      #     "message": "Material not exists.",
+      #     "details": {}
+      #   }
+      # }
+      if e.class.name == 'ParamsChecker::MyError' && is_outest_hash
+          errors.add(:errors, {
+              message: e,
+              details: {}
+          })
+      else
+          raise e
+      end
+    end
+
+    def error_exist?
+      !errors.empty? && errors.is_a?(Hash)
+    end
+
+    def default_check
+      params_is_a_hash = params.is_a?(ActionController::Parameters) || params.is_a?(Hash)
+      errors.add(:error, "ParamsChecker only receive object or ActionController::Parameters as input.") unless params_is_a_hash
+      params_is_a_hash && all_fields_are_valid
+    end
+
+    def all_fields_are_valid
+      return @all_fields_are_valid if @all_fields_are_valid.present?
+
+      @all_fields_are_valid = true
+      fields.each do |key, value|
+          @all_fields_are_valid = false unless data_valid? key
+      end
+      @all_fields_are_valid
+    end
+
+    def data_valid? key
+      if value_need_to_be_present?(key)
+        if value_present?(key)
+          if value_valid?(key) 
+              true
+          else
+              false
+          end
+        else
+          errors.add(key, 'This field is required.')
+          false
+        end
+      else
+        if value_present?(key)
+          if value_valid?(key) 
+              true
+          else    
+              false
+          end
+        else
+            true
+        end
+      end
+    end
+
+    def value_need_to_be_present? key
+      if fields[key].key?(:default) && !fields[key][:default].nil?
+        @params[key] = fields[key][:default]
+        true
+      else
+        fields[key][:required]
+      end
+    end
+
+    def value_present? key
+      params.key?(key)
+    end
+
+    def value_valid? key
+      cmd = check_base_on_field_type key
+      if cmd.success?
+          @formatted_params_after_default_check[key] = cmd.result
+      else
+          errors.add(key, cmd.errors[key])
+      end
+      cmd.success?
+    end
+
+    def fields
+      field_params = {}
+      init.each do |key, field|
+          field_params[key] = field
+      end
+      @fields ||= field_params
+    end
+
+    def check_base_on_field_type key
+      case fields[key][:type]
+      when 'num'
+          ParamChecker::NumParamChecker.call key, fields, params
+      when 'int'  
+          ParamChecker::IntParamChecker.call key, fields, params
+      when 'char'
+          ParamChecker::CharParamChecker.call key, fields, params
+      when 'text'
+          ParamChecker::CharParamChecker.call key, fields, params
+      when 'arr'
+          ParamChecker::ArrParamChecker.call key, fields, params
+      when 'nested_hash'
+          ParamChecker::NestedHashChecker.call key, fields, params, context
+      when 'nested_hashs'
+          ParamChecker::NestedHashsChecker.call key, fields, params, context
+      when 'date'
+          ParamChecker::DateParamChecker.call key, fields, params
+      when 'time'
+          ParamChecker::TimeParamChecker.call key, fields, params
+      when 'datetime'
+          ParamChecker::DateTimeParamChecker.call key, fields, params
+      when 'email'
+          ParamChecker::EmailParamChecker.call key, fields, params
+      when 'boolean'
+          ParamChecker::BooleanChecker.call key, fields, params
+      end
+    end
+
+    def custom_check
+      specify_field_checks && all_fields_check
+    end
+
+    def specify_field_checks
+      @formatted_params_after_custom_specify_field_checks = formatted_params_after_default_check
+      fields.each do |key, value|
+        # next unless self.methods.grep(/check_#{key}/).length > 0
+        next unless "check_#{key}".to_sym.in?(self.methods)
+        
+        specify_field_check(key)
+      end
+    end
+
+    def specify_field_check(key)
+      check_method = "check_#{key}"
+      total_parameters = method(check_method).arity
+      # check_id(id) or check_id(id, opts)
+      value = total_parameters == 1 ? self.send(check_method, @formatted_params_after_default_check[key])
+                                    : self.send(check_method, @formatted_params_after_default_check[key], @formatted_params_after_default_check)
+      @formatted_params_after_custom_specify_field_checks.delete(key)
+      @formatted_params_after_custom_specify_field_checks[key] = value
+    end
+
+    def all_fields_check
+      @formatted_params_after_custom_all_fields_check = check formatted_params_after_custom_specify_field_checks
+    end
+
+    def init
+      {}
+    end
+
+    def check params
+      params
+    end
+
+    def formatted_params
+      formatted_params_after_custom_all_fields_check
+    end
+
+    def add_error()
+      # only add errors skeleton at the outest hash
+      return unless is_outest_hash
+
+      details = {}
+      errors.each do |key, value|
+          details[key] = value
+          errors.delete(key)
+      end
+      errors.add(:errors, {
+          message: 'Invalid data',
+          details: details
+      })
+    end
+
+    attr_accessor :params, :context,
+      :formatted_params_after_default_check,
+        :formatted_params_after_custom_specify_field_checks,
+        :formatted_params_after_custom_all_fields_check,
+        :is_outest_hash
+  end
+end
+
+
+# return true if value_need_to_be_present?(key) && value_present?(key) && value_valid?(key) 
+# return false if value_need_to_be_present?(key) && value_present?(key) && !value_valid?(key) 
+# return false if value_need_to_be_present?(key) && !value_present?(key) && value_valid?(key) 
+# return false if value_need_to_be_present?(key) && !value_present?(key) && !value_valid?(key) 
+# return true if !value_need_to_be_present?(key) && value_present?(key) && value_valid?(key) 
+# return false if !value_need_to_be_present?(key) && value_present?(key) && !value_valid?(key) 
+# return true if !value_need_to_be_present?(key) && !value_present?(key) && value_valid?(key) 
+# return true if !value_need_to_be_present?(key) && !value_present?(key) && !value_valid?(key) 

data/lib/params_checker/engine.rb

@@ -0,0 +1,7 @@
+module ParamsChecker
+  class Engine < ::Rails::Engine
+    isolate_namespace ParamsChecker
+  end
+  class NotEngine
+  end
+end

data/lib/params_checker/fields.rb

@@ -0,0 +1,228 @@
+
+
+module ParamsChecker
+  module Fields
+    def text_field(required: true, default: nil, allow_blank: false, min_length: 0, max_length: 30_000, allow_nil: false)
+      raise "This field's type must be integer." if [min_length, max_length].any? { |value| !value.is_a?(Integer) }
+      raise "This field's type must be boolean." if [required, allow_blank, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid text length.' unless (min_length >= 0) && (max_length <= 30_000)
+    
+      {
+          type: 'char',
+          default: default,
+          allow_blank: allow_blank,
+          required: required,
+          min_length: min_length,
+          max_length: max_length,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def char_field(required: true, default: nil, allow_blank: false, min_length: 0, max_length: 255, allow_nil: false)
+      raise "This field's type must be integer." if [min_length, max_length].any? { |value| !value.is_a?(Integer) }
+      raise "This field's type must be boolean." if [required, allow_blank, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid char length.' unless (min_length >= 0) && (max_length <= 255)
+    
+      {
+          type: 'char',
+          default: default,
+          allow_blank: allow_blank,
+          required: required,
+          min_length: min_length,
+          max_length: max_length,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def bignum_field(required: true, default: nil, min: -2_000_000_000_000, max: 2_000_000_000_000, allow_nil: false)
+      raise "This field's type must be numeric." if [min, max].any? { |value| !value.is_a?(Numeric) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid numeric value.' unless (min >= -2_000_000_000_000) && (max <= 2_000_000_000_000)
+    
+      {
+          type: 'num',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def num_field(required: true, default: nil, min: -2_000_000_000, max: 2_000_000_000, allow_nil: false)
+      raise "This field's type must be numeric." if [min, max].any? { |value| !value.is_a?(Numeric) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid numeric value.' unless (min >= -2_000_000_000) && (max <= 2_000_000_000)
+    
+      {
+          type: 'num',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+
+    def bigint_field(required: true, default: nil, min: -2_000_000_000_000, max: 2_000_000_000_000, allow_nil: false)
+      raise "This field's type must be integer." if [min, max].any? { |value| !value.is_a?(Integer) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid integer value.' unless (min >= -2_000_000_000_000) && (max <= 2_000_000_000_000)
+    
+      {
+          type: 'int',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def int_field(required: true, default: nil, min: -2_000_000_000, max: 2_000_000_000, allow_nil: false)
+      raise "This field's type must be integer." if [min, max].any? { |value| !value.is_a?(Integer) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid integer value.' unless (min >= -2_000_000_000) && (max <= 2_000_000_000)
+    
+      {
+          type: 'int',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+
+    # asdasda
+
+    def positive_bignum_field(required: true, default: nil, min: 0, max: 2_000_000_000_000, allow_nil: false)
+      raise "This field's type must be numeric." if [min, max].any? { |value| !value.is_a?(Numeric) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid numeric value.' unless (min >= 0) && (max <= 2_000_000_000_000)
+    
+      {
+          type: 'num',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def positive_num_field(required: true, default: nil, min: 0, max: 2_000_000_000, allow_nil: false)
+      raise "This field's type must be numeric." if [min, max].any? { |value| !value.is_a?(Numeric) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid numeric value.' unless (min >= 0) && (max <= 2_000_000_000)
+    
+      {
+          type: 'num',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+
+    def positive_bigint_field(required: true, default: nil, min: 0, max: 2_000_000_000_000, allow_nil: false)
+      raise "This field's type must be integer." if [min, max].any? { |value| !value.is_a?(Integer) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid integer value.' unless (min >= 0) && (max <= 2_000_000_000_000)
+    
+      {
+          type: 'int',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def positive_int_field(required: true, default: nil, min: 0, max: 2_000_000_000, allow_nil: false)
+      raise "This field's type must be integer." if [min, max].any? { |value| !value.is_a?(Integer) }
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+      raise 'Invalid integer value.' unless (min >= 0) && (max <= 2_000_000_000)
+    
+      {
+          type: 'int',
+          default: default,
+          required: required,
+          min: min,
+          max: max,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def arr_field(required: true, default: nil, allow_empty: false, allow_nil: false)
+      raise "This field's type must be boolean." if [required, allow_empty, allow_nil].any? { |value| !value.in? [true, false] }
+    
+      {
+          type: 'arr',
+          default: default,
+          required: required,
+          allow_empty: allow_empty,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def date_field(required: true, default: nil, allow_nil: false)
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+    
+      {
+          type: 'date',
+          default: default,
+          required: required,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def time_field(required: true, default: nil, allow_nil: false)
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+    
+      {
+          type: 'time',
+          default: default,
+          required: required,
+          allow_nil: allow_nil
+      }
+    end
+    
+    def datetime_field(required: true, default: nil, allow_nil: false)
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+    
+      {
+          type: 'datetime',
+          default: default,
+          required: required,
+          allow_nil: allow_nil
+      }
+    end
+
+    def email_field(required: true, default: nil, allow_nil: false)
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+    
+      {
+          type: 'email',
+          default: default,
+          required: required,
+          allow_nil: allow_nil
+      }
+    end
+
+    def boolean_field(required: true, default: nil, allow_nil: false)
+      raise "This field's type must be boolean." if [required, allow_nil].any? { |value| !value.in? [true, false] }
+    
+      {
+          type: 'boolean',
+          default: default,
+          required: required,
+          allow_nil: allow_nil
+      }
+    end
+
+  end
+  
+end

data/lib/params_checker/my_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ParamsChecker
+  class MyError < StandardError
+    def initialize(message)
+        super(message)
+    end
+  end
+end

data/lib/params_checker/param_checker.rb

@@ -0,0 +1,291 @@
+module ParamsChecker
+    module ParamChecker
+        class BaseParamChecker
+            def initialize(key = '', fields = {}, opts = {})
+                @key = key
+                @fields = fields
+                @opts = opts
+            end
+        
+            def call; end
+        
+            def add_error(message = '')
+                errors.add(key, message)
+            end
+        
+            attr_accessor :key, :fields, :opts
+        end
+        
+        class NumParamChecker < BaseParamChecker
+            prepend SimpleCommand
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                check_type && check_param
+                opts[key]
+            end
+        
+            def check_type
+                valid = opts[key].is_a? Numeric
+                add_error("This field's type must be numeric.") unless valid
+                valid
+            end
+        
+            def check_param
+                min = fields[key][:min]
+                max = fields[key][:max]
+                valid =(min..max).include? opts[key]
+                add_error("This numeric field's value must be in range from #{min} to #{max}.") unless valid
+                valid
+            end
+        end
+
+        class IntParamChecker < BaseParamChecker
+          prepend SimpleCommand
+      
+          def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+              check_type && check_param
+              opts[key]
+          end
+      
+          def check_type
+              valid = opts[key].is_a? Integer
+              add_error("This field's type must be integer.") unless valid
+              valid
+          end
+      
+          def check_param
+              min = fields[key][:min]
+              max = fields[key][:max]
+              valid = (min..max).include? opts[key]
+              add_error("This integer field's value must be in range from #{min} to #{max}.") unless valid
+              valid
+          end
+        end
+        
+        class CharParamChecker < BaseParamChecker
+            prepend SimpleCommand
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                check_type && check_allow_blank && check_length && opts[key]
+            end
+        
+            def check_type
+                valid = opts[key].is_a?(String)
+                add_error("This field's type must be string.") unless valid
+                valid
+            end
+        
+            def check_allow_blank
+                valid = !(!fields[key][:allow_blank] && opts[key].blank?)
+                add_error('This field cannot be blank.') unless valid
+                valid
+            end
+        
+            def check_length
+                min_length = fields[key][:min_length]
+                max_length = fields[key][:max_length]
+                valid = (min_length..max_length).include? opts[key].length
+                add_error("This string field's length must be in range from #{min_length} to #{max_length}.") unless valid
+                valid
+            end
+        end
+        
+        class ArrParamChecker < BaseParamChecker
+            prepend SimpleCommand
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                check_type && check_allow_empty && opts[key]
+            end
+        
+            def check_type
+                valid =opts[key].is_a? Array
+                add_error("This field's type must be array.") unless valid
+                valid
+            end
+        
+            def check_allow_empty
+                valid =!(!fields[key][:allow_empty] && opts[key].empty?)
+                add_error('This field cannot be empty.') unless valid
+                valid
+            end
+        end
+
+        class NestedHashChecker
+            prepend SimpleCommand
+            def initialize(key = '', fields = {}, opts = {}, context = {})
+                @key = key
+                @fields = fields
+                @opts = opts
+                @context = context
+            end
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                check_type && formatted_nested_hash
+            end
+
+            def formatted_nested_hash
+                cmd = fields[key][:class].call(params:opts[key], context: context, is_outest_hash: false)
+                if cmd.success?
+                    cmd.result
+                else
+                    add_error cmd.errors
+                end
+            end
+
+            def check_type
+                valid = opts[key].is_a?(ActionController::Parameters) || opts[key].is_a?(Hash)
+                add_error("This field's type must be object or ActionController::Parameters.") unless valid
+                valid
+            end
+
+            def add_error(message = '')
+                errors.add(key, message)
+            end
+        
+            attr_accessor :key, :fields, :opts, :class, :context
+        end
+
+        class NestedHashsChecker
+            prepend SimpleCommand
+            def initialize(key = '', fields = {}, opts = {}, context = {})
+                @key = key
+                @fields = fields
+                @opts = opts
+                @context = context
+            end
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                check_type && formatted_nested_hashs
+            end
+
+            def formatted_nested_hashs
+                opts[key].map do |nested_hash|
+                  formatted_nested_hash(nested_hash)
+                end
+            end
+
+            def formatted_nested_hash nested_hash
+                cmd = fields[key][:class].call(params: nested_hash, context: context, is_outest_hash: false)
+                if cmd.success?
+                    cmd.result
+                else
+                    add_error cmd.errors
+                end
+            end
+
+            def check_type
+                valid = opts[key].is_a?(Array)
+                add_error("This field's type must be array.") unless valid
+                valid
+            end
+        
+            def add_error(message = '')
+                errors.add(key, message)
+            end
+        
+            attr_accessor :key, :fields, :opts, :class, :context
+        end
+                
+        class DateParamChecker < BaseParamChecker
+            prepend SimpleCommand
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                formatted_date
+            end
+        
+            def formatted_date
+                Date.parse opts[key]
+            rescue => e
+                add_error 'Invalid date.'
+            end
+        end
+
+        class TimeParamChecker < BaseParamChecker
+            prepend SimpleCommand
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                formatted_time
+            end
+        
+            def formatted_time
+                Time.parse opts[key]
+            rescue => e
+                add_error 'Invalid time.'
+            end
+        end
+
+        class DateTimeParamChecker < BaseParamChecker
+            prepend SimpleCommand
+        
+            def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+                formatted_datetime
+            end
+        
+            def formatted_datetime
+                DateTime.parse(opts[key])
+            rescue => e
+                add_error 'Invalid datetime.'
+            end
+        end
+
+        class EmailParamChecker < BaseParamChecker
+          prepend SimpleCommand
+      
+          def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+              check_type && check_regrex && opts[key]
+          end
+      
+          def check_type
+              valid = opts[key].is_a? String
+              add_error("Invalid email.") unless valid
+              valid
+          end
+      
+          def check_regrex
+              valid = opts[key].match(URI::MailTo::EMAIL_REGEXP)
+              add_error('Invalid email.') unless valid
+              valid
+          end
+      
+        end
+
+        class BooleanChecker < BaseParamChecker
+          prepend SimpleCommand
+      
+          def call
+                return nil if fields[key][:allow_nil] && opts[key].nil?
+
+              check_type && opts[key]
+          end
+      
+          def check_type
+              valid = opts[key].in? [true, false]
+              add_error("This field's type must be boolean.") unless valid
+              valid
+          end
+      
+        end
+
+    end
+end
+

data/lib/params_checker/version.rb

@@ -0,0 +1,3 @@
+module ParamsChecker
+  VERSION = '0.2.1'
+end

data/lib/params_checker.rb

@@ -0,0 +1,9 @@
+require "simple_command"
+require "params_checker/engine"
+require "params_checker/fields"
+require "params_checker/my_error"
+require "params_checker/param_checker"
+require "params_checker/base_params_checker"
+module ParamsChecker
+end
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: params_checker
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- rexy tech
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Description of RexyAdmin.
+email:
+- ted@rexy.tech
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/params_checker_manifest.js
+- app/assets/stylesheets/params_checker/application.css
+- app/controllers/params_checker/application_controller.rb
+- app/helpers/params_checker/application_helper.rb
+- app/jobs/params_checker/application_job.rb
+- app/mailers/params_checker/application_mailer.rb
+- app/models/params_checker/application_record.rb
+- app/views/layouts/params_checker/application.html.erb
+- config/routes.rb
+- lib/params_checker.rb
+- lib/params_checker/base_params_checker.rb
+- lib/params_checker/engine.rb
+- lib/params_checker/fields.rb
+- lib/params_checker/my_error.rb
+- lib/params_checker/param_checker.rb
+- lib/params_checker/version.rb
+homepage: https://rexy.tech/
+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: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: ParamsChecker.
+test_files: []