request_params_validation 0.1.0

data/lib/request_params_validation/params/constants.rb

@@ -0,0 +1,22 @@
+module RequestParamsValidation
+  module Params
+    module Constants
+      HASH_TYPE     = :hash
+      ARRAY_TYPE    = :array
+      STRING_TYPE   = :string
+      INTEGER_TYPE  = :integer
+      DECIMAL_TYPE  = :decimal
+      BOOLEAN_TYPE  = :boolean
+      DATE_TYPE     = :date
+      DATETIME_TYPE = :datetime
+      EMAIL_TYPE    = :email
+
+      INTEGER_REGEXP = /^[+-]?([1-9]\d*|0)$/
+      DECIMAL_REGEXP = /^[+-]?([1-9]\d*|0)(\.[0-9]+)?$/
+      EMAIL_REGEXP   = /\A[a-zA-Z0-9.!\#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\z/
+
+      BOOLEAN_TRUE_VALUES  = [true, 'true']   + RequestParamsValidation.extends.boolean_true_values
+      BOOLEAN_FALSE_VALUES = [false, 'false'] + RequestParamsValidation.extends.boolean_false_values
+    end
+  end
+end

data/lib/request_params_validation/params/converter.rb

@@ -0,0 +1,33 @@
+require 'request_params_validation/params/types/conversions'
+
+module RequestParamsValidation
+  module Params
+    module Converter
+      extend Params::Types::Conversions
+
+      def self.coerce(param, value)
+        type = param.type
+
+        method_name = "convert_to_#{type}"
+
+        return value unless self.respond_to?(method_name)
+
+        if [Params::DATE_TYPE, Params::DATETIME_TYPE].include?(type)
+          self.send(method_name, value, param.format.try(:strptime))
+        elsif type == Params::DECIMAL_TYPE
+          self.send(method_name, value, param.decimal_precision)
+        else
+          self.send(method_name, value)
+        end
+      end
+
+      def self.apply_transformation(param, value)
+        transform = param.transform
+
+        return value unless transform
+
+        transform.respond_to?(:call) ? transform.call(value) : value.send(transform)
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/types/conversions.rb

@@ -0,0 +1,41 @@
+module RequestParamsValidation
+  module Params
+    module Types
+      module Conversions
+        def convert_to_string(value)
+          String(value)
+        end
+
+        def convert_to_integer(value)
+          Integer(value)
+        end
+
+        def convert_to_decimal(value, precision)
+          precision = precision || RequestParamsValidation.formats.decimal_precision
+
+          value = Float(value)
+
+          value = value.round(precision) if precision
+
+          value
+        end
+
+        def convert_to_boolean(value)
+          Params::BOOLEAN_TRUE_VALUES.include?(value)
+        end
+
+        def convert_to_date(value, format)
+          format = format || RequestParamsValidation.formats.date
+
+          format ? Date.strptime(value, format) : Date.parse(value)
+        end
+
+        def convert_to_datetime(value, format)
+          format = format || RequestParamsValidation.formats.datetime
+
+          format ? DateTime.strptime(value, format) : DateTime.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/types/validations.rb

@@ -0,0 +1,57 @@
+module RequestParamsValidation
+  module Params
+    module Types
+      module Validations
+        def valid_array?(value)
+          value.is_a?(Array)
+        end
+
+        def valid_hash?(value)
+          value.is_a?(Hash) || value.is_a?(ActionController::Parameters)
+        rescue NameError # For older versions of Rails
+          false
+        end
+
+        def valid_string?(value)
+          true
+        end
+
+        def valid_integer?(value)
+          !!(value.to_s =~ Params::INTEGER_REGEXP)
+        end
+
+        def valid_decimal?(value)
+          !!(value.to_s =~ Params::DECIMAL_REGEXP)
+        end
+
+        def valid_email?(value)
+          !!(value =~ Params::EMAIL_REGEXP)
+        end
+
+        def valid_boolean?(value)
+          (Params::BOOLEAN_TRUE_VALUES + Params::BOOLEAN_FALSE_VALUES).include?(value)
+        end
+
+        def valid_date?(value, format)
+          format = format || RequestParamsValidation.formats.date
+
+          format ? Date.strptime(value, format) : Date.parse(value)
+
+          true
+        rescue ArgumentError, TypeError
+          false
+        end
+
+        def valid_datetime?(value, format)
+          format = format || RequestParamsValidation.formats.datetime
+
+          format ? DateTime.strptime(value, format) : DateTime.parse(value)
+
+          true
+        rescue ArgumentError, TypeError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validator.rb

@@ -0,0 +1,74 @@
+require 'request_params_validation/params/converter'
+
+Dir[File.join(File.dirname(__FILE__), 'validators/**/*.rb')].each { |f| require f }
+
+module RequestParamsValidation
+  module Params
+    class Validator
+
+      Validators.constants(false).each do |validator|
+        include Validators.const_get(validator)
+      end
+
+      attr_reader :param, :value, :original_value
+
+      def initialize(param_definition, value)
+        @param = param_definition
+        @value = value
+        @original_value = value
+      end
+
+      def validate_and_coerce
+        validate_presence! if param.validate_presence?
+
+        if value.blank? && param.has_default?
+          @value = param.default
+          return value
+        end
+
+        return value if value.nil?
+
+        validate_type! if param.validate_type?
+
+        case param.type
+        when Params::ARRAY_TYPE
+          iterate_array
+        when Params::HASH_TYPE
+          iterate_hash
+        end
+
+        @value = Params::Converter.coerce(param, value)
+
+        validate_inclusion!         if param.validate_inclusion?
+        validate_length!            if param.validate_length?
+        validate_value!             if param.validate_value?
+        validate_format!            if param.validate_format?
+        validate_custom_validation! if param.validate_custom_validation?
+
+        @value = Params::Converter.apply_transformation(param, value)
+      end
+
+      private
+
+      def iterate_array
+        value.map! do |element_value|
+          self.class.new(param.elements, element_value).validate_and_coerce
+        end
+      end
+
+      def iterate_hash
+        Params::validate!(param.sub_definition, value) # recursion for the sub_definition
+      end
+
+      def raise_error(exception_type, options = {})
+        options = options.merge(
+          param_key: param.key,
+          param_value: original_value,
+          param_type: param.type
+        )
+
+        raise RequestParamsValidation.exceptions.send(exception_type).new(options)
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/custom.rb

@@ -0,0 +1,18 @@
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Custom
+        def validate_custom_validation!
+          result = param.custom_validation.function.call(value)
+
+          unless result
+            raise_error(
+              :on_invalid_parameter_custom_validation,
+              details: param.custom_validation.message
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/format.rb

@@ -0,0 +1,27 @@
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Format
+        def validate_format!
+          regexp = param.format.regexp
+
+          if value !~ regexp
+            raise_error(
+              :on_invalid_parameter_format,
+              regexp: regexp,
+              details: param.format.message || default_invalid_format_message
+            )
+          end
+        end
+
+        def default_invalid_format_message
+          if param.element_of_array?
+            'An element of the array has an invalid format'
+          else
+            'Value format is invalid'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/inclusion.rb

@@ -0,0 +1,27 @@
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Inclusion
+        def validate_inclusion!
+          include_in = param.inclusion.in
+
+          unless include_in.include?(value)
+            raise_error(
+              :on_invalid_parameter_inclusion,
+              include_in: include_in,
+              details: param.inclusion.message || default_invalid_inclusion_message(include_in)
+            )
+          end
+        end
+
+        def default_invalid_inclusion_message(include_in)
+          if param.element_of_array?
+            "All elements values of the array should be in #{include_in}"
+          else
+            "Value should be in #{include_in}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/length.rb

@@ -0,0 +1,37 @@
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Length
+        def validate_length!
+          min = param.length.min
+          max = param.length.max
+
+          if (min && value.length < min) || (max && value.length > max)
+            raise_error(
+              :on_invalid_parameter_length,
+              min: min,
+              max: max,
+              details: param.length.message || default_invalid_length_message(min, max)
+            )
+          end
+        end
+
+        def default_invalid_length_message(min, max)
+          message = if param.element_of_array?
+                      'All elements of the array should have a length'
+                    else
+                      'Length should be'
+                    end
+
+          if min && max
+            min == max ? "#{message} equal to #{max}" : "#{message} between #{min} and #{max}"
+          elsif min
+            "#{message} greater or equal than #{min}"
+          else
+            "#{message} less or equal than #{max}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/presence.rb

@@ -0,0 +1,13 @@
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Presence
+        def validate_presence!
+          not_present = param.allow_blank ? value.nil? : value.blank?
+
+          raise_error(:on_missing_parameter) if not_present
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/type.rb

@@ -0,0 +1,59 @@
+require 'request_params_validation/params/types/validations'
+
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Type
+        include Params::Types::Validations
+        include RequestParamsValidation.extends.types if RequestParamsValidation.extends.types
+
+        def validate_type!
+          type = param.type
+
+          method_name = "valid_#{type}?"
+
+          unless self.respond_to?(method_name)
+            raise UnsupportedTypeError.new(param_key: param.key, param_type: type)
+          end
+
+          valid = if [Params::DATE_TYPE, Params::DATETIME_TYPE].include?(type)
+                    self.send(method_name, value, param.format.try(:strptime))
+                  else
+                    self.send(method_name, value)
+                  end
+
+          unless valid
+            raise_error(
+              :on_invalid_parameter_type,
+              details: default_invalid_type_message(type)
+            )
+          end
+        end
+
+        def default_invalid_type_message(type)
+          type = :object if type == Params::HASH_TYPE
+
+          message = if param.element_of_array?
+                      "All elements of the array should be a valid #{type}"
+                    else
+                      "Value should be a valid #{type}"
+                    end
+
+          if [Params::DATE_TYPE, Params::DATETIME_TYPE].include?(type)
+            format = param.format.try(:strptime) || RequestParamsValidation.formats.send(type)
+
+            if format
+              message = if param.format.try(:message)
+                          param.format.message
+                        else
+                          "#{message} with the format #{format}"
+                        end
+            end
+          end
+
+          message
+        end
+      end
+    end
+  end
+end

data/lib/request_params_validation/params/validators/value.rb

@@ -0,0 +1,37 @@
+module RequestParamsValidation
+  module Params
+    module Validators
+      module Value
+        def validate_value!
+          min = param.value.min
+          max = param.value.max
+
+          if (min && value < min) || (max && value > max)
+            raise_error(
+              :on_invalid_parameter_value_size,
+              min: min,
+              max: max,
+              details: param.value.message || default_invalid_value_message(min, max)
+            )
+          end
+        end
+
+        def default_invalid_value_message(min, max)
+          message = if param.element_of_array?
+                      'All elements of the array should have a value'
+                    else
+                      'Value should be'
+                    end
+
+          if min && max
+            "#{message} between #{min} and #{max}"
+          elsif min
+            "#{message} greater or equal than #{min}"
+          else
+            "#{message} less or equal than #{max}"
+          end
+        end
+      end
+    end
+  end
+end