params_checker 0.2.2 → 0.2.3

data/lib/params_checker/base_params_checker.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+DEFAULT_MESSAGE_ERROR = 'Fields are not valid'
+ERROR_TYPES = %w[general_error field_errors]
 module ParamsChecker
   class BaseParamsChecker
     include Fields
@@ -6,244 +10,265 @@ module ParamsChecker
       @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 = {}
+      @formatted_params_after_default_fields_check = {}
+      @formatted_params_after_custom_fields_check = {}
+      @formatted_params_after_custom_overall_check = {}
+      @custom_check_errors = {}
     end
 
-    def self.init required: true, many: false 
-      raise "This field's type must be boolean." if [required, many].any? { |value| !value.in? [true, false] }
+    def self.init(required: true, many: false, default: nil, allow_nil: false)
+      raise "This field's type must be boolean." if [required, many, allow_nil].any? { |value| !value.in? [true, false] }
 
       type = many ? 'nested_hashs' : 'nested_hash'
+
       {
-          type: type,
-          required: required,
-          many: many,
-          class: self
+        type: type,
+        required: required,
+        default: default,
+        allow_nil: allow_nil,
+        many: many,
+        class: self
       }
     end
 
-    def raise_error message="Invalid data"
-      raise MyError.new(message)
+    def raise_error(message = DEFAULT_MESSAGE_ERROR)
+      raise GeneralError.new(message)
+    end
+
+    def add_error(message, key = nil)
+      raise ParamsChecker::FieldError.new({
+        message: message,
+        key: key,
+      })
     end
 
     def call
-      default_check && custom_check
-      error_exist? && add_error
+      default_fields_check && custom_check
+      error_exist? && add_errors
       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
+    rescue ParamsChecker::GeneralError => e
+      # if is the outest hash, add error
+      # if is not, keep raising error, bubble up to the outest hash,
+      # then the outest hash will add error
+      unless is_outest_hash
+        raise e
       end
+
+      errors.add(
+        :errors,
+        {
+          message: e.message,
+          error_type: 'general_error'
+        }
+      )
     end
 
     def error_exist?
-      !errors.empty? && errors.is_a?(Hash)
+      errors.present? && errors.is_a?(Hash) || @custom_check_errors.present?
+    end
+
+    def default_fields_check
+      params_is_not_a_hash = !params.is_a?(ActionController::Parameters) && !params.is_a?(Hash)
+
+      if params_is_not_a_hash
+        errors.add(:error, 'ParamsChecker only receive object or ActionController::Parameters as input.')
+      end
+
+      all_fields_of_params_are_valid?
     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
+    def custom_check
+      fields_check && overall_check
     end
 
-    def all_fields_are_valid
-      return @all_fields_are_valid if @all_fields_are_valid.present?
+    def all_fields_of_params_are_valid?
+      @all_fields_of_params_are_valid ||= field_valids.all?(true)
+    end
 
-      @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
+    def field_valids
+      @field_valids ||=
+        schema.map do |key, _|
+          set_default_value(key) if need_to_set_default_value?(key)
+
+          field_is_valid?(key)
         end
-      end
     end
 
-    def value_need_to_be_present? key
-      if fields[key].key?(:default) && !fields[key][:default].nil?
-        @params[key].nil? && @params[key] = fields[key][:default]
+    def field_is_valid?(key)
+      return value_valid?(key) if value_present?(key)
 
-        true
-      else
-        fields[key][:required]
-      end
+      return true unless value_need_to_be_present?(key)
+
+      errors.add(key, 'This field is required.')
+      false
     end
 
-    def value_present? key
+    def need_to_set_default_value?(key)
+      value_is_nil = @params[key].nil?
+      schema_field_has_default_value_key = schema[key].key?(:default)
+      default_value_is_set = !schema[key][:default].nil?
+
+      value_is_nil &&
+        schema_field_has_default_value_key &&
+        default_value_is_set
+    end
+
+    def set_default_value(key)
+      @params[key] = schema[key][:default]
+    end
+
+    def value_need_to_be_present?(key)
+      return true if schema[key].key?(:default) && !schema[key][:default].nil?
+
+      schema[key][:required]
+    end
+
+    def value_present?(key)
       params.key?(key)
     end
 
-    def value_valid? key
-      cmd = check_base_on_field_type key
+    def value_valid?(key)
+      cmd = check_base_on_field_type(key)
       if cmd.success?
-          @formatted_params_after_default_check[key] = cmd.result
+        @formatted_params_after_default_fields_check[key] = cmd.result
       else
-          errors.add(key, cmd.errors[key])
+        errors.add(key, cmd.errors[key])
       end
       cmd.success?
     end
 
-    def fields
-      field_params = {}
-      init.each do |key, field|
-          field_params[key] = field
+    def schema
+      @schema ||= init.each_with_object({}) do |error, hash|
+        key, value = error
+        hash[key] = value
       end
-      @fields ||= field_params
     end
 
-    def check_base_on_field_type key
-      case fields[key][:type]
+    def check_base_on_field_type(key)
+      case schema[key][:type]
       when 'num'
-          ParamChecker::NumParamChecker.call key, fields, params
-      when 'int'  
-          ParamChecker::IntParamChecker.call key, fields, params
+        ParamChecker::NumParamChecker.call(key, schema, params)
+      when 'int'
+        ParamChecker::IntParamChecker.call(key, schema, params)
       when 'char'
-          ParamChecker::CharParamChecker.call key, fields, params
+        ParamChecker::CharParamChecker.call(key, schema, params)
       when 'text'
-          ParamChecker::CharParamChecker.call key, fields, params
+        ParamChecker::CharParamChecker.call(key, schema, params)
       when 'arr'
-          ParamChecker::ArrParamChecker.call key, fields, params
+        ParamChecker::ArrParamChecker.call(key, schema, params)
+      when 'hash'
+        ParamChecker::HashParamChecker.call(key, schema, params)
       when 'nested_hash'
-          ParamChecker::NestedHashChecker.call key, fields, params, context
+        ParamChecker::NestedHashChecker.call(key, schema, params, context)
       when 'nested_hashs'
-          ParamChecker::NestedHashsChecker.call key, fields, params, context
+        ParamChecker::NestedHashsChecker.call(key, schema, params, context)
       when 'date'
-          ParamChecker::DateParamChecker.call key, fields, params
+        ParamChecker::DateParamChecker.call(key, schema, params)
       when 'time'
-          ParamChecker::TimeParamChecker.call key, fields, params
+        ParamChecker::TimeParamChecker.call(key, schema, params)
       when 'datetime'
-          ParamChecker::DateTimeParamChecker.call key, fields, params
-      when 'email'
-          ParamChecker::EmailParamChecker.call key, fields, params
+        ParamChecker::DateTimeParamChecker.call(key, schema, params)
       when 'boolean'
-          ParamChecker::BooleanChecker.call key, fields, params
+        ParamChecker::BooleanChecker.call(key, schema, params)
       when 'file'
-          ParamChecker::FileChecker.call key, fields, params
+        ParamChecker::FileChecker.call(key, schema, 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|
+    def fields_check
+      @formatted_params_after_custom_fields_check = formatted_params_after_default_fields_check
+      schema.each do |key, _|
         # next unless self.methods.grep(/check_#{key}/).length > 0
-        next unless "check_#{key}".to_sym.in?(self.methods)
-        
-        specify_field_check(key)
+        need_to_check = "check_#{key}".to_sym.in?(methods)
+        passed_default_check = errors[key].nil?
+
+        next unless need_to_check && passed_default_check
+
+        field_check(key)
       end
     end
 
-    def specify_field_check(key)
+    def 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
+      # pp "========>total_parameters : ", total_parameters
+
+      value = if total_parameters == 1
+                # like check_name(name)
+                send(check_method, @formatted_params_after_default_fields_check[key])
+              elsif total_parameters == 2
+                # like check_name(name, opts)
+                send(check_method, @formatted_params_after_default_fields_check[key], @formatted_params_after_default_fields_check)
+              end
+
+      @formatted_params_after_custom_fields_check[key] = value
+    rescue ParamsChecker::FieldError => e
+      # binding.pry
+      key = e.data[:key].presence || key
+      @custom_check_errors[key] = e.data[:message]
     end
 
-    def all_fields_check
-      @formatted_params_after_custom_all_fields_check = check formatted_params_after_custom_specify_field_checks
+    def overall_check
+      @formatted_params_after_custom_overall_check = check(formatted_params_after_custom_fields_check)
+    rescue ParamsChecker::FieldError => e
+      key = e.data[:key]
+      @custom_check_errors[key] = e.data[:message]
     end
 
     def init
       {}
     end
 
-    def check params
+    def check(params)
       params
     end
 
     def formatted_params
-      formatted_params_after_custom_all_fields_check
+      formatted_params_after_custom_overall_check
     end
 
-    def add_error()
-      # only add errors skeleton at the outest hash
-      return unless is_outest_hash
+    def add_errors
+      # only add errors at the outest hash
+      # return unless is_outest_hash
+
+      field_errors = errors.each_with_object({}) do |error, hash|
+        key, value = error
+        value = value.is_a?(Array) ? value[0] : value
+        hash[key] = value
 
-      details = {}
-      errors.each do |key, value|
-          details[key] = value
-          errors.delete(key)
+        errors.delete(key)
       end
-      errors.add(:errors, {
-          message: 'Invalid data',
-          details: details
-      })
+
+      @custom_check_errors.each do |key, value|
+        field_errors[key] = value
+      end
+
+      errors.add(
+        :errors,
+        {
+          message: DEFAULT_MESSAGE_ERROR,
+          error_type: 'fields_errors',
+          field_errors: field_errors
+        }
+      )
     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
+    attr_accessor :params,
+                  :context,
+                  :formatted_params_after_default_fields_check,
+                  :formatted_params_after_custom_fields_check,
+                  :formatted_params_after_custom_overall_check,
+                  :is_outest_hash,
+                  # :message,
+                  :custom_check_errors
   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) 
+# 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/constants.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Constants
+  ERROR_MESSAGES = {
+    required: 'This field is required.',
+    blank: 'This field cannot be blank.',
+    empty: 'This field cannot be empty.',
+
+    type: {
+      string: "This field's type must be string.",
+      file: "This field's type must be file.",
+      hash: "This field's type must be hash.",
+      nested_hash: "This field's type must be object or ActionController::Parameters.",
+      array: "This field's type must be array.",
+      integer: "This field's type must be integer.",
+      numeric: "This field's type must be numeric.",
+      boolean: "This field's type must be boolean.",
+      date: 'Invalid date.',
+      time: 'Invalid time.',
+      datetime: 'Invalid datetime.'
+    },
+
+    length: {
+      text: 'Invalid text length.',
+      char: 'Invalid char length.'
+    },
+
+    value: {
+      numeric: 'Invalid numeric value.',
+      integer: 'Invalid integer value.'
+    }
+  }.freeze
+
+  def get_integer_value_error_message(min: -2_000_000_000_000, max: 2_000_000_000_000)
+    "This integer field's value must be in range from #{min} to #{max}."
+  end
+
+  def get_numeric_value_error_message(min: -2_000_000_000_000, max: 2_000_000_000_000)
+    "This numeric field's value must be in range from #{min} to #{max}."
+  end
+
+  def get_string_length_error_message(min_length: 0, max_length: 30_000)
+    "This string field's length must be in range from #{min_length} to #{max_length}."
+  end
+end

data/lib/params_checker/engine.rb

@@ -1,6 +1,10 @@
 module ParamsChecker
   class Engine < ::Rails::Engine
     isolate_namespace ParamsChecker
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
   end
   class NotEngine
   end

data/lib/params_checker/field_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ParamsChecker
+  class FieldError < StandardError
+    attr_accessor :data
+
+    def initialize(data)
+      @data = data
+    end
+  end
+end