validate-params 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7ca97c7e091dd9ec8f28cb7fcfe146ec315e4d7513f145b0a27015c5ecf826d
-  data.tar.gz: 9b6159617d663834cf65707aa80a51e5e411dc03f218588e9136069494269ce7
+  metadata.gz: 7626ebe2f24591c008739bce05f28938e39094dc057ce65b227e7f99130c21cc
+  data.tar.gz: 10f86e031e06e0c8723792d399881d4cc9baa64d9841eca1a1123c13606519ea
 SHA512:
-  metadata.gz: 5738ecc1bec5808caaa44a71633beb13e0e2ffe77fea4921afea41d1e2d44852833f2f6783b2fbb05cd8f4b140587051a1b5008d0020d13166eb2fb8a059e12b
-  data.tar.gz: 7d688728061b1a044b564ad199649828d961f0b9bcc21f3b3b19861723048fa2ff5eaad6527e758052c9aebdd04fda5068998c957d62063125a98f866e0ce403
+  metadata.gz: b90773a69bdb7d7a8f65df932f78c3c0da3b4937540d4da8ca89695a0113548dffbe45760ff49ee0d6e89b718fb1d689c3f778a0887562290d2e5092956e13a7
+  data.tar.gz: 18a1f5f2d8b0aec4210e8ad50f9d1a715e6f1aa01ab7cf74af77c4fffdbbe4b1f0c16a38b9b57a1df2a83cb3834bb7a9d908ff1b981a71206131e2c4ffaa7726

data/.rubocop.yml

@@ -1,13 +1,365 @@
 AllCops:
-  TargetRubyVersion: 2.7
+  TargetRubyVersion: 2.7.0
 
+# https://edgeguides.rubyonrails.org/contributing_to_ruby_on_rails.html#follow-the-coding-conventions
+
+# No blank line after access modifiers
+Layout/EmptyLinesAroundAccessModifier:
+  EnforcedStyle: only_before
+
+# Hard to use with WSL2
+Layout/EndOfLine:
+  Enabled: false
+
+# First element shall always be relative to the first position of the line where the opening bracket is
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+# First key shall always be relative to the first position of the line where the opening brace is
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+
+# Table-like left alignment of keys, hash rockets, and values
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+
+# Method definitions after access modifiers isolated calls need one extra level of indentation
+Layout/IndentationConsistency:
+  EnforcedStyle: indented_internal_methods
+
+# The second operand should be indented is binary operations that span more than one line
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+# Braces around single line blocks, do..end around multi-line blocks, except for multi-line blocks
+# whose return value is being chained with another method
+Style/BlockDelimiters:
+  EnforcedStyle: braces_for_chaining
+
+# Enforce the block end operator to go on its own line in empty methods
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+# Enforce absence of braces around hash literal as a last array item
+Style/HashAsLastArrayItem:
+  EnforcedStyle: no_braces
+
+# Use double quotes for string literals
 Style/StringLiterals:
-  Enabled: true
   EnforcedStyle: double_quotes
 
+# Use double quotes inside expressions in interpolated strings
 Style/StringLiteralsInInterpolation:
-  Enabled: true
   EnforcedStyle: double_quotes
 
+# Use %w or %W for arrays of words whose element count is greater than or equal to 5
+Style/WordArray:
+  MinSize: 5
+
+Style/BlockComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedShorthandSyntax: never
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Bundler/OrderedGems:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+# ┌──────────────────────────────────────────────────────────┐
+# │TODO: Consider refactoring and applying the following cops│
+# └──────────────────────────────────────────────────────────┘
+
+Style/ClassVars:
+  Enabled: false
+
+Style/CombinableLoops:
+  Enabled: false
+
+Style/For:
+  Enabled: false
+
+Style/FloatDivision:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/HashLikeCase:
+  Enabled: false
+
+Style/IdenticalConditionalBranches:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/InfiniteLoop:
+  Enabled: false
+
+Style/InverseMethods:
+  Enabled: false
+
+Style/KeywordParametersOrder:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/LineEndConcatenation:
+  Enabled: false
+
+Style/MixinUsage:
+  Enabled: false
+
+Style/NegatedIf:
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+Style/Not:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+Style/MultipleComparison:
+  Enabled: false
+
+Style/MultilineTernaryOperator:
+  Enabled: false
+
+Style/MutableConstant:
+  Enabled: false
+
+Style/NestedParenthesizedCalls:
+  Enabled: false
+
+Style/NestedTernaryOperator:
+  Enabled: false
+
+Style/NumericLiteralPrefix:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/OptionalBooleanParameter:
+  Enabled: false
+
+Style/OrAssignment:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/PreferredHashMethods:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/RedundantAssignment:
+  Enabled: false
+
+Style/RedundantFetchBlock:
+  Enabled: false
+
+Style/RedundantInterpolation:
+  Enabled: false
+
+Style/RedundantRegexpEscape:
+  Enabled: false
+
+Style/RedundantSelf:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/RescueModifier:
+  Enabled: false
+
+Style/RescueStandardError:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/SlicingWithRange:
+  Enabled: false
+
+Style/SoleNestedConditional:
+  Enabled: false
+
+Style/StringConcatenation:
+  Enabled: false
+
+Style/StructInheritance:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Style/SymbolProc:
+  Enabled: false
+
+Style/UnlessElse:
+  Enabled: true
+
+Style/WhileUntilDo:
+  Enabled: false
+
+Style/WhileUntilModifier:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: false
+
+Lint/BooleanSymbol:
+  Enabled: false
+
+Lint/CircularArgumentReference:
+  Enabled: false
+
+Lint/DisjunctiveAssignmentInConstructor:
+  Enabled: false
+
+Lint/DuplicateMethods:
+  Enabled: false
+
+Lint/EmptyConditionalBody:
+  Enabled: false
+
+Lint/EmptyWhen:
+  Enabled: false
+
+Style/IfInsideElse:
+  Enabled: false
+
+Lint/IneffectiveAccessModifier:
+  Enabled: false
+
+Lint/MissingSuper:
+  Enabled: false
+
+Lint/NestedMethodDefinition:
+  Enabled: false
+
+Lint/NonDeterministicRequireOrder:
+  Enabled: false
+
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: false
+
+Lint/RedundantWithIndex:
+  Enabled: false
+
+Lint/RequireParentheses:
+  Enabled: false
+
+Lint/RescueException:
+  Enabled: false
+
+Lint/ShadowedArgument:
+  Enabled: false
+
+Lint/SuppressedException:
+  Enabled: false
+
+Lint/ToJSON:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Lint/UriRegexp:
+  Enabled: false
+
+Lint/UselessAccessModifier:
+  Enabled: false
+
 Layout/LineLength:
-  Max: 120
+  Enabled: false
+
+Naming/AccessorMethodName:
+  Enabled: false
+
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Naming/PredicateName:
+  Enabled: false
+
+Naming/VariableNumber:
+  Enabled: false
+
+# ┌──────────────────────────────────────────────────────────┐
+# │Enabled pending cops. Remove when added to default config │
+# └──────────────────────────────────────────────────────────┘
+
+Style/StringChars:
+  Enabled: true
+
+Style/RedundantInitialize:
+  Enabled: true
+
+Style/CaseEquality:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.7.0] - 2023-05-30
+
+- Added type support for casting params into types
+- Added support for Array of types [String, Integer]
+
 ## [0.5.2] - 2023-05-29
 
 - Support to handle HTML and JSON response formats

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    validate-params (0.6.1)
+    validate-params (0.7.0)
       activesupport (>= 6.1.0)
+      i18n (>= 1.6)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -26,6 +26,8 @@ class TestController < ActionController::Base
     p.param :name, String, default: "John Doe"
     p.param :occurred_on, Date, required: true, default: proc { Date.today }
     p.param :quantity, Integer, required: true, in: [1, 2, 3]
+    p.param :user_ids, Array, of: Integer, default: [1, 2, 3]
+    p.param :states, Array, of: String, default: ["active", "inactive"]
     p.param :date_of_birth, Hash do |pp|
       pp.param :gt, Date
       pp.param :lt, Date

data/docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3'
+
+services:
+  app:
+    image: ruby:3.1.4
+    working_dir: /app
+    volumes:
+      - ./:/app
+      - bundler:/usr/local/bundle/
+
+volumes:
+  bundler:

data/lib/validate_params/param_builder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ValidateParams
+  module Validatable
+    class ParamBuilder
+      def initialize(parent_field = nil)
+        @parent_field = parent_field
+        @params_validations = []
+      end
+
+      def param(field, type, options = {})
+        return { field: field, type: type, options: options } if @parent_field.nil?
+
+        @params_validations << { field: { @parent_field => field }, type: type, options: options }
+        @params_validations
+      end
+    end
+  end
+end

data/lib/validate_params/param_validator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module ValidateParams
+  module Validatable
+    class ParamValidator
+      def self.call(**args)
+        new(**args).call
+      end
+
+      def initialize(type:, field:, value:, errors:, options: {})
+        @type = type
+        @field = field
+        @value = value
+        @errors = errors
+        @options = options
+      end
+
+      def call
+        return if @value.blank? && !@options[:required]
+
+        if @value.blank? && @options[:required]
+          @errors << { message: required_error_message }
+          return
+        end
+
+        send(@type.to_s.underscore)
+      end
+
+      private
+        def array
+          return if Types::Array.valid?(@value, of: @options[:of])
+
+          @errors << { message: error_message }
+        end
+
+        def date
+          return if Types::Date.valid?(@value)
+
+          @errors << { message: error_message }
+        end
+
+        def date_time
+          return if Types::DateTime.valid?(@value)
+
+          @errors << { message: error_message }
+        end
+
+        def integer
+          unless Types::Integer.valid?(@value)
+            @errors << { message: error_message }
+            return
+          end
+
+          validate_inclusion if @options[:in].present?
+        end
+
+        def string
+          validate_inclusion if @options[:in].present?
+        end
+
+        def validate_inclusion
+          return if @options[:in].include?(value)
+
+          @errors << {
+            message: I18n.t("validate_params.invalid_in", param: error_param_name),
+            valid_values: @options[:in]
+          }
+        end
+
+        def error_param_name
+          case @field
+          when Array
+            "#{@field[0]}[#{@field[1]}]"
+          when Hash
+            @field.map { |k, v| "#{k}[#{v}]" }.first
+          else
+            @field
+          end
+        end
+
+        def error_message
+          I18n.t("validate_params.invalid_type", param: error_param_name, type: @type)
+        end
+
+        def required_error_message
+          I18n.t("validate_params.required", param: error_param_name)
+        end
+    end
+  end
+end

data/lib/validate_params/types/array.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ValidateParams
+  class Types
+    class Array
+      def self.valid?(value, of: String)
+        case of.to_s
+        when "Integer"
+          value.all? { |item| Types::Integer.valid?(item) }
+        else
+          true
+        end
+      end
+
+      def self.cast(raw_value, of: String)
+        case of.to_s
+        when "Integer"
+          raw_value.map { |item| Types::Integer.cast(item) }
+        else
+          raw_value
+        end
+      end
+    end
+  end
+end

data/lib/validate_params/types/date.rb

@@ -1,19 +1,32 @@
-module ValidateParams
-  class Types
-    class Date
-      def self.valid?(value)
-        value = value.to_s
-        return false if !/\d{4}-\d{2}-\d{2}/.match?(value)
-
-        parsed_date = begin
-                        ::Date.strptime(value, "%Y-%m-%d")
-                      rescue StandardError
-                        nil
-                      end
-        return false if parsed_date.nil?
-        return false if parsed_date.year > 9999
-        true
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ValidateParams
+  class Types
+    class Date
+      FORMAT = "%Y-%m-%d"
+
+      def self.valid?(value)
+        value = value.to_s
+        return false unless /\d{4}-\d{2}-\d{2}/.match?(value)
+
+        parsed_date = begin
+          ::Date.strptime(value, FORMAT)
+        rescue StandardError
+          nil
+        end
+        return false if parsed_date.nil?
+        return false if parsed_date.year > 9999
+
+        true
+      end
+
+      def self.cast(raw_value)
+        return raw_value if raw_value.is_a?(::Date)
+
+        ::Date.strptime(raw_value.to_s, FORMAT)
+      rescue StandardError
+        raw_value
+      end
+    end
+  end
+end

data/lib/validate_params/types/date_time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ValidateParams
   class Types
     class DateTime
@@ -7,6 +9,14 @@ module ValidateParams
       rescue ArgumentError, TypeError
         false
       end
+
+      def self.cast(raw_value)
+        return raw_value if raw_value.is_a?(::Time)
+
+        Time.at(Integer(raw_value))
+      rescue ArgumentError, TypeError
+        raw_value
+      end
     end
   end
-end
+end

data/lib/validate_params/types/integer.rb

@@ -1,10 +1,15 @@
-module ValidateParams
-  class Types
-    class Integer
-      def self.valid?(value)
-        value = value.to_s
-        /\A[-+]?\d+\z/ === value
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ValidateParams
+  class Types
+    class Integer
+      def self.valid?(value)
+        /\A[-+]?\d+\z/ === value.to_s
+      end
+
+      def self.cast(raw_value)
+        raw_value.to_i
+      end
+    end
+  end
+end

data/lib/validate_params/types/string.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ValidateParams
+  class Types
+    class String
+      def self.cast(raw_value)
+        raw_value.to_s
+      end
+    end
+  end
+end

data/lib/validate_params/validatable.rb

@@ -3,6 +3,11 @@
 require "validate_params/types/date"
 require "validate_params/types/date_time"
 require "validate_params/types/integer"
+require "validate_params/types/array"
+require_relative "param_builder"
+require_relative "param_validator"
+
+require "active_support/concern"
 
 module ValidateParams
   module Validatable
@@ -48,142 +53,106 @@ module ValidateParams
     end
 
     private
-
-    def build_error_message(param, type)
-      I18n.t("validate_params.invalid_type", param: param, type: type)
-    end
-
-    def build_required_message(param)
-      I18n.t("validate_params.required", param: param)
-    end
-
-    def error_param_name(field)
-      case field
-      when Array
-        "#{field[0]}[#{field[1]}]"
-      when Hash
-        field.map { |k, v| "#{k}[#{v}]" }.first
-      else
-        field
-      end
-    end
-
-    def set_params_defaults
-      params_validations.each do |params_validation|
-        next if params_validation[:options][:default].blank?
-
-        if params_validation[:field].is_a?(Hash)
-          params_validation[:field].each_key do |key|
-            # Skip in case hash is configured and string is passed
-            next if params.dig(key).is_a? Hash
-            next if params.dig(key, params_validation[:field][key])
-
+      def set_params_defaults
+        params_validations.each do |params_validation|
+          next unless params_validation[:options].key?(:default)
+
+          if params_validation[:field].is_a?(Hash)
+            params_validation[:field].each_key do |key|
+              # Skip in case hash is configured and string is passed
+              next if params[key].is_a? Hash
+              next if params.dig(key, params_validation[:field][key])
+
+              value = if params_validation[:options][:default].is_a?(Proc)
+                        params_validation[:options][:default].call
+                      else
+                        params_validation[:options][:default]
+                      end
+              params.deep_merge!(key => { params_validation[:field][key] => value })
+            end
+          else
             value = if params_validation[:options][:default].is_a?(Proc)
                       params_validation[:options][:default].call
                     else
                       params_validation[:options][:default]
                     end
-            params.merge!(key => { params_validation[:field][key] => value })
-          end
-        else
-          value = if params_validation[:options][:default].is_a?(Proc)
-                    params_validation[:options][:default].call
-                  else
-                    params_validation[:options][:default]
-                  end
-
-          params[params_validation[:field]] ||= value
-        end
-      end
-    end
-
-    def perform_validate_params
-      return unless controller_action.present? && controller_action == action_name.to_sym
-
-      errors = []
 
-      for params_validation in params_validations
-        # Skip in case hash is configured and string is passed
-        next if params_validation[:field].is_a?(Hash) &&
-          params.dig(params_validation[:field].keys.first).is_a?(String)
+            params[params_validation[:field]] ||= value
 
-        parameter_value = if params_validation[:field].is_a? Hash
-                            params.dig(params_validation[:field].keys.first,
-                                       params_validation[:field][params_validation[:field].keys.first])
-                          else
-                            params[params_validation[:field]]
-                          end
-
-        next if parameter_value.blank? && !params_validation[:options][:required]
-
-        if parameter_value.blank? && params_validation[:options][:required]
-          errors << { message: build_required_message(error_param_name(params_validation[:field])) }
-          next
-        end
-
-        case params_validation[:type].to_s
-        when "Date"
-          unless ValidateParams::Types::Date.valid?(parameter_value)
-            errors << {
-              message: build_error_message(error_param_name(params_validation[:field]), params_validation[:type])
-            }
-          end
-        when "DateTime"
-          unless ValidateParams::Types::DateTime.valid?(parameter_value)
-            errors << {
-              message: build_error_message(error_param_name(params_validation[:field]), params_validation[:type])
-            }
-          end
-        when "Integer"
-          unless ValidateParams::Types::Integer.valid?(parameter_value)
-            errors << {
-              message: build_error_message(error_param_name(params_validation[:field]), params_validation[:type])
-            }
-            next
-          end
-
-          parameter_value = parameter_value.to_i
-          if params_validation[:options][:in].present? && !params_validation[:options][:in].include?(parameter_value)
-            errors << {
-              message: I18n.t("validate_params.invalid_in", param: error_param_name(params_validation[:field])),
-              valid_values: params_validation[:options][:in]
-            }
-          end
-        when "String"
-          parameter_value = parameter_value.to_s
-          if params_validation[:options][:in].present? && !params_validation[:options][:in].include?(parameter_value)
-            errors << {
-              message: I18n.t("validate_params.invalid_in", param: error_param_name(params_validation[:field])),
-              valid_values: params_validation[:options][:in]
-            }
           end
         end
       end
 
-      return if errors.empty?
-
-      case response_format
-      when :html
-        head :bad_request
-      else
-        render json: { success: false, errors: errors }, status: :bad_request
+      def cast_param_values
+        params_validations.each do |params_validation|
+          if params_validation[:field].is_a?(Hash)
+            params_validation[:field].each_key do |key|
+              next unless params[key].is_a?(Hash)
+
+              value = params.dig(key, params_validation[:field][key])
+              next if value.blank?
+
+              params.deep_merge!(
+                key => {
+                  params_validation[:field][key] => if params_validation[:type].name == "Array"
+                                                      Types.const_get(params_validation[:type].name).cast(value,
+                                                                                                          of: params_validation[:options][:of])
+                                                    else
+                                                      Types.const_get(params_validation[:type].name).cast(value)
+                                                    end
+                }
+              )
+            end
+          else
+            value = params[params_validation[:field]]
+            next if value.blank?
+
+            params[params_validation[:field]] = if params_validation[:type].name == "Array"
+                                                  Types.const_get(params_validation[:type].name).cast(value, of: params_validation[:options][:of])
+                                                else
+                                                  Types.const_get(params_validation[:type].name).cast(value)
+                                                end
+          end
+        end
       end
-    end
 
-    class ParamBuilder
-      def initialize(parent_field = nil)
-        @parent_field = parent_field
-        @params_validations = []
-      end
+      def perform_validate_params
+        return unless controller_action.present? && controller_action == action_name.to_sym
+
+        errors = []
+
+        params_validations.each do |params_validation|
+          # Skip in case hash is configured and string is passed
+          next if params_validation[:field].is_a?(Hash) &&
+            params[params_validation[:field].keys.first].is_a?(String)
+
+          parameter_value = if params_validation[:field].is_a? Hash
+                              params.dig(params_validation[:field].keys.first,
+                                         params_validation[:field][params_validation[:field].keys.first])
+                            else
+                              params[params_validation[:field]]
+                            end
+
+          ParamValidator.call(
+            type: params_validation[:type],
+            field: params_validation[:field],
+            value: parameter_value,
+            errors: errors,
+            options: params_validation[:options]
+          )
+        end
 
-      def param(field, type, options = {})
-        unless @parent_field
-          return { field: field, type: type, options: options }
+        if errors.empty?
+          cast_param_values
+          return
         end
 
-        @params_validations << { field: { @parent_field => field }, type: type, options: options }
-        @params_validations
+        case response_format
+        when :html
+          head :bad_request
+        else
+          render json: { success: false, errors: errors }, status: :bad_request
+        end
       end
-    end
   end
 end

data/lib/validate_params/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ValidateParams
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/lib/validate_params.rb

@@ -2,8 +2,8 @@
 
 require_relative "validate_params/version"
 require_relative "validate_params/validatable"
-Dir[File.join(__dir__, 'validate_params/types', '*.rb')].each { |file| require file }
-Dir[File.join(__dir__, 'validate_params/validators', '*.rb')].each { |file| require file }
+
+Dir[File.join(__dir__, "validate_params/types", "*.rb")].sort.each { |file| require file }
 
 module ValidateParams
   class Error < StandardError; end

data/validate_params.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
 
   spec.add_dependency "activesupport", ">= 6.1.0"
+  spec.add_dependency "i18n", ">= 1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: validate-params
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - dcherevatenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-29 00:00:00.000000000 Z
+date: 2023-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.1.0
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
 description: Provides a clean DSL to validate params for controller actions.
 email:
 - 'denis.cherevatenko@peopleforce.io '
@@ -95,12 +109,16 @@ files:
 - README.md
 - Rakefile
 - config/locales/en.yml
+- docker-compose.yml
 - lib/validate_params.rb
+- lib/validate_params/param_builder.rb
+- lib/validate_params/param_validator.rb
+- lib/validate_params/types/array.rb
 - lib/validate_params/types/date.rb
 - lib/validate_params/types/date_time.rb
 - lib/validate_params/types/integer.rb
+- lib/validate_params/types/string.rb
 - lib/validate_params/validatable.rb
-- lib/validate_params/validators/date.rb
 - lib/validate_params/version.rb
 - sig/validate_params.rbs
 - validate_params.gemspec