request_params_validation 0.1.0

data/lib/request_params_validation/definitions/param.rb

@@ -0,0 +1,182 @@
+require 'request_params_validation/params'
+require 'request_params_validation/exceptions/definitions_errors'
+
+module RequestParamsValidation
+  module Definitions
+    class Param
+      attr_reader :key, :required, :allow_blank, :type, :transform, :decimal_precision,
+                  :inclusion, :length, :value, :format, :custom_validation, :elements
+
+      def initialize(options, &block)
+        @key         = options[:key]
+        @required    = options[:required]
+        @allow_blank = options[:allow_blank]
+        @type        = options[:type].try(:to_sym)
+        @default     = options[:default]
+
+        @transform          = options[:transform]
+        @decimal_precision  = options[:precision]
+        @element_of_array   = options[:element_of_array]
+
+        @inclusion          = build_inclusion_option(options[:inclusion])
+        @length             = build_length_option(options[:length])
+        @value              = build_value_option(options[:value])
+        @format             = build_format_option(options[:format])
+        @custom_validation  = build_custom_validation_option(options[:validate])
+
+        @elements           = build_elements_option(options[:elements], &block)
+        @sub_definition     = build_sub_definition(&block)
+      end
+
+      def has_default?
+        !@default.nil? # default value could be `false`
+      end
+
+      def default
+        @default.respond_to?(:call) ? @default.call : @default
+      end
+
+      def sub_definition
+        @sub_definition || @elements.try(:sub_definition)
+      end
+
+      def element_of_array?
+        !!@element_of_array
+      end
+
+      def validate_presence?
+        !!@required
+      end
+
+      def validate_type?
+        !!@type
+      end
+
+      def validate_inclusion?
+        !!@inclusion
+      end
+
+      def validate_length?
+        !!@length
+      end
+
+      def validate_value?
+        !!@value
+      end
+
+      def validate_format?
+        return false if [Params::DATE_TYPE, Params::DATETIME_TYPE].include?(@type)
+
+        !!@format
+      end
+
+      def validate_custom_validation?
+        !!@custom_validation
+      end
+
+      private
+
+      def build_inclusion_option(inclusion)
+        case inclusion
+        when Array
+          include_in = inclusion
+        when Hash
+          include_in = inclusion[:in]
+          message = inclusion[:message]
+        end
+
+        return unless include_in
+
+        Struct.new(:in, :message).new(include_in, message)
+      end
+
+      def build_length_option(length)
+        case length
+        when Integer
+          min = length
+          max = length
+        when Hash
+          min = length[:min]
+          max = length[:max]
+          message = length[:message]
+        end
+
+        return unless min || max
+
+        Struct.new(:min, :max, :message).new(min, max, message)
+      end
+
+      def build_value_option(value)
+        case value
+        when Hash
+          min = value[:min]
+          max = value[:max]
+          message = value[:message]
+        end
+
+        return unless min || max
+
+        Struct.new(:min, :max, :message).new(min, max, message)
+      end
+
+      def build_format_option(format)
+        case format
+        when Regexp
+          regexp = format
+        when String
+          strptime = format
+        when Hash
+          strptime = format[:strptime]
+          regexp   = format[:regexp]
+          message  = format[:message]
+        end
+
+        return if regexp.nil? && !strptime
+
+        Struct.new(:regexp, :strptime, :message).new(regexp, strptime, message)
+      end
+
+      def build_custom_validation_option(validation)
+        case validation
+        when Proc
+          function = validation
+        when Hash
+          function = validation[:function]
+          message = validation[:message]
+        end
+
+        return unless function
+
+        Struct.new(:function, :message).new(function, message)
+      end
+
+      def build_elements_option(elements, &block)
+        return unless @type == Params::ARRAY_TYPE
+
+        elements_options = {
+          key: @key,
+          element_of_array: true
+        }
+
+        case elements
+        when Hash
+          elements_options.merge!(elements)
+        when String, Symbol
+          elements_options.merge!(type: elements)
+        end
+
+        self.class.new(elements_options, &block)
+      end
+
+      def build_sub_definition(&block)
+        return unless @type == Params::HASH_TYPE
+
+        request = Request.new
+
+        block.call(request) if block_given?
+
+        request.params
+      end
+    end
+  end
+end

data/lib/request_params_validation/definitions/request.rb

@@ -0,0 +1,31 @@
+require 'request_params_validation/definitions/param'
+
+module RequestParamsValidation
+  module Definitions
+    class Request
+      attr_reader :params
+
+      def initialize
+        @params = []
+      end
+
+      def required(param_name, options = {}, &block)
+        options = options.merge({ required: true })
+        add_parameter(param_name, options, &block)
+      end
+
+      def optional(param_name, options = {}, &block)
+        options = options.merge({ required: false })
+        add_parameter(param_name, options, &block)
+      end
+
+      private
+
+      def add_parameter(name, options, &block)
+        options = options.merge({ key: name })
+
+        @params << Param.new(options, &block)
+      end
+    end
+  end
+end

data/lib/request_params_validation/definitions/resource.rb

@@ -0,0 +1,30 @@
+require 'request_params_validation/definitions/action'
+require 'request_params_validation/exceptions/definitions_errors'
+
+module RequestParamsValidation
+  module Definitions
+    class Resource
+      attr_reader :name, :actions
+
+      def initialize(name)
+        @name = name
+        @actions = {}
+      end
+
+      def action(action_name)
+        unless block_given?
+          raise DefinitionArgumentError.new("Expecting block for action '#{action_name}'")
+        end
+
+        action_definition = Action.new(action_name.to_s)
+
+        yield action_definition
+
+        @actions[action_name.to_s] = action_definition
+      rescue DefinitionArgumentError => e
+        e.resource = name
+        raise
+      end
+    end
+  end
+end

data/lib/request_params_validation/engine.rb

@@ -0,0 +1,18 @@
+module RequestParamsValidation
+  autoload :Definitions, 'request_params_validation/definitions'
+  autoload :Helpers,     'request_params_validation/helpers'
+
+  class Engine < ::Rails::Engine
+    isolate_namespace RequestParamsValidation
+
+    initializer 'request_params_validation.load_definitions' do
+      RequestParamsValidation::Definitions.load_all
+    end
+
+    initializer 'request_params_validation.add_helpers' do
+      ActiveSupport.on_load :action_controller do
+        include RequestParamsValidation::Helpers
+      end
+    end
+  end
+end

data/lib/request_params_validation/exceptions/base_errors.rb

@@ -0,0 +1,10 @@
+module RequestParamsValidation
+  class GeneralError < StandardError
+  end
+
+  class RequestParamError < GeneralError
+  end
+
+  class DefinitionsError < GeneralError
+  end
+end

data/lib/request_params_validation/exceptions/definitions_errors.rb

@@ -0,0 +1,31 @@
+require 'request_params_validation/exceptions/base_errors'
+
+module RequestParamsValidation
+  class DefinitionNotFoundError < DefinitionsError
+    def initialize(resource, action)
+      msg = "The request definition for the resource '#{resource}' and action '#{action}' " \
+            "couldn't be found"
+
+      super(msg)
+    end
+  end
+
+  class DefinitionArgumentError < DefinitionsError
+    attr_accessor :resource, :action
+
+    def initialize(error_msg, options = {})
+      @error_msg = error_msg
+      @resource  = options[:resource]
+
+      super(message)
+    end
+
+    def message
+      if resource
+        "Argument error for resource '#{resource}'. #{@error_msg}"
+      else
+        @error_msg
+      end
+    end
+  end
+end

data/lib/request_params_validation/exceptions/validator_errors.rb

@@ -0,0 +1,49 @@
+require 'request_params_validation/exceptions/base_errors'
+
+module RequestParamsValidation
+  class MissingParameterError < RequestParamError
+    attr_reader :param_key, :param_type
+
+    def initialize(options)
+      @param_key   = options[:param_key]
+      @param_type  = options[:param_type]
+
+      super(message)
+    end
+
+    def message
+      "The parameter '#{param_key}' is missing"
+    end
+  end
+
+  class InvalidParameterValueError < RequestParamError
+    attr_reader :param_key, :param_value, :param_type, :details
+
+    def initialize(options)
+      @param_key   = options[:param_key]
+      @param_value = options[:param_value]
+      @param_type  = options[:param_type]
+      @details     = options[:details]
+
+      super(message)
+    end
+
+    def message
+      message = "The value for the parameter '#{param_key}' is invalid"
+
+      if details.present?
+        "#{message}. #{details}"
+      else
+        message
+      end
+    end
+  end
+
+  class UnsupportedTypeError < GeneralError
+    def initialize(options)
+      msg = "Unsupported type '#{options[:param_type]}' for the parameter '#{options[:param_key]}'"
+
+      super(msg)
+    end
+  end
+end

data/lib/request_params_validation/handler.rb

@@ -0,0 +1,26 @@
+require 'request_params_validation/definitions'
+require 'request_params_validation/params'
+require 'request_params_validation/exceptions/definitions_errors'
+
+module RequestParamsValidation
+  module Handler
+    def self.handle_request_params(resource, action, params)
+      request_definition = Definitions.get_request(resource, action)
+
+      unless request_definition
+        case RequestParamsValidation.on_definition_not_found
+        when :raise
+          raise DefinitionNotFoundError.new(resource, action)
+        else
+          return
+        end
+      end
+
+      RequestParamsValidation.remove_keys_from_params.each { |key| params.delete(key) }
+
+      Params.validate!(request_definition.params, params)
+
+      Params.filter!(request_definition.params, params) if RequestParamsValidation.filter_params
+    end
+  end
+end

data/lib/request_params_validation/helpers.rb

@@ -0,0 +1,17 @@
+require 'request_params_validation/handler'
+
+module RequestParamsValidation
+  module Helpers
+    define_method RequestParamsValidation.helper_method_name do
+      resource = params[:controller]
+      action = params[:action]
+
+      if RequestParamsValidation.save_original_params
+        original_params = params.deep_dup
+        instance_variable_set(RequestParamsValidation.save_original_params, original_params)
+      end
+
+      Handler.handle_request_params(resource, action, params)
+    end
+  end
+end

data/lib/request_params_validation/params.rb

@@ -0,0 +1,60 @@
+require 'request_params_validation/params/constants'
+require 'request_params_validation/params/validator'
+
+module RequestParamsValidation
+  module Params
+    include Constants
+
+    def self.validate!(definition, params)
+      definition.each do |param_definition|
+        validate_and_coerce_param(param_definition, params)
+      end
+
+      params
+    end
+
+    def self.filter!(definition, params)
+      extra_keys = [:controller, :action] # Keys added by Rails
+
+      filter_params(definition, params, extra_keys).tap do |params|
+        params.permit! if params.respond_to?(:permit!)
+      end
+    end
+
+    def self.validate_and_coerce_param(param_definition, params)
+      key = param_definition.key
+      value = params[key]
+
+      value = Validator.new(param_definition, value).validate_and_coerce
+
+      params[key] = value
+    end
+    private_class_method :validate_and_coerce_param
+
+    def self.filter_params(definition, params, extra_keys = [])
+      return unless params
+      return params if definition.empty?
+
+      params_keys = definition.map do |param_definition|
+        key = param_definition.key
+
+        if param_definition.sub_definition
+          filter_params(param_definition.sub_definition, params[key])
+        end
+
+        key
+      end.compact
+
+      params_keys += extra_keys
+
+      if params.is_a?(Array)
+        params.map { |param| param.slice!(*params_keys) }
+      else
+        params.slice!(*params_keys)
+      end
+
+      params
+    end
+    private_class_method :filter_params
+  end
+end