rails_simple_params 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5d43833fa90c412a87b2c9fbb770b772fa4108bea779f48d26585b5f71cac96
+  data.tar.gz: 59780a29ba6d6e06cc69129d7c55ec0d7207213e00db452cfa547957b3df9f41
+SHA512:
+  metadata.gz: e4dcec56bd8a60f7e86c66c44aee6e0f69e632fca2ab77c251421c68f254fbebf23c0d8eb909a2d014af9ca51a2348c24103f19613028c67a0d65522218a3ec6
+  data.tar.gz: 4d07862e2593a5ffb3567e7cf04203690186c5fba6aaab74bcc4c8b7d1d2f6c5cc8c5283990e2ee912fe7895b4b1c54b9e4d1eae5ba390f4ed62b375fc2c4c3e

data/README.md

@@ -0,0 +1,168 @@
+# rails_simple_params
+_Parameter Validation & Type Coercion for Rails_
+
+## Introduction
+
+This library is handy if you want to validate a few numbers of parameters
+directly inside your controller.
+
+For example: you are building a search action and want to validate that the
+`sort` parameter is set and only set to something like `desc` or `asc`.
+
+## Important
+
+This library should not be used to validate a large number of parameters or
+parameters sent via a form or namespaced (like `params[:user][:first_name]`).
+There is already a great framework included in Rails (ActiveModel::Model) which
+can be used to create virtual classes with all the validations you already know
+and love from Rails. Remember to always try to stay in the “thin controller” rule.
+
+[See an example on how to build a contact form using ActiveModel::Model.][active-model-example]
+
+Sometimes it’s not practical to create an external class just to validate and
+convert a few parameters. This gem allows you to easily validate and convert
+parameters directly in your controller actions using a simple method call.
+
+## Credits
+
+This is a fork of the gem [rails_param][gem-rails-param], which was itself a
+port of the gem [sinatra-param][gem-sinatra-param] for the Rails framework.
+
+## Installation
+
+As usual, in your Gemfile...
+
+``` ruby
+  gem 'rails_simple_params'
+```
+
+## Example
+
+``` ruby
+  # GET /search?q=example
+  # GET /search?q=example&categories=news
+  # GET /search?q=example&sort=created_at&order=ASC
+  def search
+    param! :q,          String, required: true
+    param! :categories, Array
+    param! :sort,       String, default: 'title'
+    param! :order,      String, in: %w(asc desc), transform: :downcase, default: 'asc'
+    param! :price,      String, format: /[<\=>]\s*\$\d+/
+
+    # Access the parameters using the params object (e.g. `params[:q]`) as you usually do...
+  end
+end
+```
+
+### Parameter Types
+
+By declaring parameter types, incoming parameters will automatically be
+transformed into an object of that type. For instance, if a param is `:boolean`,
+values of `'1'`, `'true'`, `'t'`, `'yes'`, and `'y'` will be automatically
+transformed into `true`. `BigDecimal` defaults to a precision of 14, and this
+can be changed by passing in the optional `precision:` argument. Any `$` and `,`
+are automatically stripped when converting to `BigDecimal`.
+
+- `String`
+- `Integer`
+- `Float`
+- `:boolean/TrueClass/FalseClass` _('1/0', 'true/false', 't/f', 'yes/no', 'y/n')_
+- `Array` _('1,2,3,4,5')_
+- `Hash` _('key1:value1,key2:value2')_
+- `Date`, `Time`, & `DateTime`
+- `BigDecimal` _('$1,000,000')_
+
+### Validations
+
+Encapsulate business logic in a consistent way with validations. If a parameter
+does not satisfy a particular condition, an exception
+(RailsSimpleParams::InvalidParameterError) is raised. You may use the
+[rescue_from][method-rescue-from] method in your controller to catch this kind
+of exception.
+
+- `required`
+- `blank`
+- `is`
+- `in`, `within`, `range`
+- `min` / `max`
+- `min_length` / `max_length`
+- `format`
+
+Customize exception message with option `:message`
+
+```ruby
+param! :q, String, required: true, message: 'Query not specified'
+```
+
+### Defaults and Transformations
+
+Passing a `default` option will provide a default value for a parameter if none
+is passed. A `default` can be defined as either a default value or as a `Proc`:
+
+```ruby
+param! :attribution, String, default: "©"
+param! :year, Integer, default: lambda { Time.now.year }
+```
+
+Use the `transform` option to take even more of the business logic of parameter
+I/O out of your code. Anything that responds to `to_proc` (including `Proc` and
+symbols) will do.
+
+```ruby
+param! :order, String, in: ['ASC', 'DESC'], transform: :upcase, default: 'ASC'
+param! :offset, Integer, min: 0, transform: lambda {|n| n - (n % 10)}
+```
+
+### Nested Attributes
+
+rails_simple_params allows you to apply any of the above mentioned validations
+to attributes nested in hashes:
+
+```ruby
+param! :book, Hash do |b|
+  b.param! :title, String, blank: false
+  b.param! :price, BigDecimal, precision: 4, required: true
+  b.param! :author, Hash, required: true do |a|
+    a.param! :first_name, String
+    a.param! :last_name, String, blank: false
+  end
+end
+```
+
+### Arrays
+
+Validate every element of your array, including nested hashes and arrays:
+
+```ruby
+# primitive datatype syntax
+param! :integer_array, Array do |array,index|
+  array.param! index, Integer, required: true
+end
+
+# complex array
+param! :books_array, Array, required: true  do |b|
+  b.param! :title, String, blank: false
+  b.param! :author, Hash, required: true do |a|
+    a.param! :first_name, String
+    a.param! :last_name, String, required: true
+  end
+  b.param! :subjects, Array do |s,i|
+    s.param! i, String, blank: false
+  end
+end
+```
+
+## Many thanks to:
+
+- [Nicolas Blanco](http://twitter.com/nblanco_fr)
+- [Mattt Thompson (@mattt)](https://twitter.com/mattt)
+- [Vincent Ollivier (@vinc686)](https://twitter.com/vinc686)
+
+## License
+
+rails_simple_params is available under the MIT license. See the LICENSE file for more info.
+
+[active-model-example]: http://blog.remarkablelabs.com/2012/12/activemodel-model-rails-4-countdown-to-2013
+[gem-rails-param]: https://github.com/nicolasblanco/rails_param
+[gem-sinatra-param]: https://github.com/mattt/sinatra-param
+[method-rescue-from]: http://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from

data/lib/rails_simple_params/coercion/array_param.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class ArrayParam < VirtualParam
+      def coerce
+        return param if param.is_a?(Array)
+
+        Array(param.split(options[:delimiter] || ','))
+      end
+
+      private
+
+      def argument_validation
+        raise ArgumentError unless type == Array
+        raise ArgumentError unless param.respond_to?(:split)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/big_decimal_param.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class BigDecimalParam < VirtualParam
+      DEFAULT_PRECISION = 14
+
+      def coerce
+        return nil if param == '' # e.g. from an empty field in an HTML form
+
+        stripped_param = if param.is_a?(String)
+                           param.delete('$,').strip.to_f
+                         else
+                           param
+                         end
+
+        BigDecimal(stripped_param, options[:precision] || DEFAULT_PRECISION)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/boolean_param.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class BooleanParam < VirtualParam
+      FALSEY = /^(false|f|no|n|0)$/i
+      TRUTHY = /^(true|t|yes|y|1)$/i
+
+      def coerce
+        return false if FALSEY === param.to_s
+        return true if TRUTHY === param.to_s
+
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/float_param.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class FloatParam < VirtualParam
+      def coerce
+        return nil if param == '' # e.g. from an empty field in an HTML form
+
+        Float(param)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/hash_param.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class HashParam < VirtualParam
+      def coerce
+        return param if param.is_a?(ActionController::Parameters)
+        raise ArgumentError unless param.respond_to?(:split)
+
+        Hash[param.split(options[:delimiter] || ',').map { |c| c.split(options[:separator] || ':') }] # rubocop:disable Style/HashConversion
+      end
+
+      private
+
+      def argument_validation
+        raise ArgumentError unless type == Hash
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/integer_param.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class IntegerParam < VirtualParam
+      def coerce
+        return nil if param == '' # e.g. from an empty field in an HTML form
+
+        Integer(param)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/string_param.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class StringParam < VirtualParam
+      def coerce
+        String(param)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/time_param.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class TimeParam < VirtualParam
+      def coerce
+        return nil if param == '' # e.g. from an empty field in an HTML form
+
+        return type.strptime(param, options[:format]) if options[:format].present?
+
+        type.parse(param)
+      end
+
+      private
+
+      def argument_validation
+        raise ArgumentError unless type.respond_to?(:parse)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion/virtual_param.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    class VirtualParam
+      attr_reader :param, :options, :type
+
+      def initialize(param:, options: nil, type: nil)
+        @param = param
+        @options = options
+        @type = type
+        argument_validation
+      end
+
+      def coerce
+        nil
+      end
+
+      private
+
+      def argument_validation
+        nil
+      end
+    end
+  end
+end

data/lib/rails_simple_params/coercion.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Coercion
+    attr_reader :coercion, :param
+
+    PARAM_TYPE_MAPPING = {
+      Integer => IntegerParam,
+      Float => FloatParam,
+      String => StringParam,
+      Array => ArrayParam,
+      Hash => HashParam,
+      BigDecimal => BigDecimalParam,
+      Date => TimeParam,
+      DateTime => TimeParam,
+      Time => TimeParam,
+      TrueClass => BooleanParam,
+      FalseClass => BooleanParam,
+      boolean: BooleanParam
+    }.freeze
+
+    TIME_TYPES = [Date, DateTime, Time].freeze
+    BOOLEAN_TYPES = [TrueClass, FalseClass, :boolean].freeze
+
+    def initialize(param, type, options)
+      @param = param
+      @coercion = klass_for(type).new(param: param, options: options, type: type)
+    end
+
+    def klass_for(type)
+      klass = PARAM_TYPE_MAPPING[type]
+      return klass if klass
+
+      raise TypeError
+    end
+
+    def coerce
+      return nil if param.nil?
+
+      coercion.coerce
+    end
+  end
+end

data/lib/rails_simple_params/invalid_parameter_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class InvalidParameterError < StandardError
+    attr_accessor :param, :options
+
+    def initialize(message, param: nil, options: {})
+      self.param = param
+      self.options = options
+      super(message)
+    end
+
+    def message
+      return options[:message] if options.is_a?(Hash) && options.key?(:message)
+
+      super
+    end
+  end
+end

data/lib/rails_simple_params/param.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  def param!(name, type, options = {}, &)
+    ParamEvaluator.new(params).param!(name, type, options, &)
+  end
+end

data/lib/rails_simple_params/param_evaluator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class ParamEvaluator
+    attr_accessor :params
+
+    def initialize(params, context = nil)
+      @params = params
+      @context = context
+    end
+
+    def param!(name, type, options = {}, &) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      name = name.to_s unless name.is_a?(Integer)
+      return unless params.include?(name) || check_param_presence?(options[:default]) || options[:required]
+
+      parameter_name = @context ? "#{@context}[#{name}]" : name
+      coerced_value = coerce(parameter_name, params[name], type, options)
+
+      parameter = RailsSimpleParams::Parameter.new(
+        name: parameter_name,
+        value: coerced_value,
+        type: type,
+        options: options,
+        &
+      )
+
+      parameter.set_default if parameter.should_set_default?
+
+      # validate presence
+      if params[name].nil? && options[:required]
+        raise InvalidParameterError.new(
+          "Parameter #{parameter_name} is required",
+          param: parameter_name,
+          options: options
+        )
+      end
+
+      recurse_on_parameter(parameter, &) if block_given?
+
+      # apply transformation
+      parameter.transform if options[:transform]
+
+      # validate
+      validate!(parameter)
+
+      # set params value
+      params[name] = parameter.value
+    end
+
+    private
+
+    def recurse_on_parameter(parameter, &) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      return if parameter.value.nil?
+
+      if parameter.type == Array
+        parameter.value.each_with_index do |element, i|
+          if element.is_a?(Hash) || element.is_a?(ActionController::Parameters)
+            recurse(element, "#{parameter.name}[#{i}]", &)
+          else
+            parameter.value[i] = recurse({ i => element }, parameter.name, i, &) # supply index as key unless value is hash
+          end
+        end
+      else
+        recurse(parameter.value, parameter.name, &)
+      end
+    end
+
+    def recurse(element, context, index = nil)
+      raise InvalidParameterError, 'no block given' unless block_given?
+
+      yield(ParamEvaluator.new(element, context), index)
+    end
+
+    def check_param_presence?(param)
+      !param.nil?
+    end
+
+    def coerce(param_name, param, type, options = {})
+      return nil if param.nil?
+      return param if begin
+        param.is_a?(type)
+      rescue StandardError
+        false
+      end
+
+      Coercion.new(param, type, options).coerce
+    rescue ArgumentError, TypeError
+      raise InvalidParameterError.new("'#{param}' is not a valid #{type}", param: param_name)
+    end
+
+    def validate!(param)
+      param.validate
+    end
+  end
+end

data/lib/rails_simple_params/parameter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Parameter
+    attr_accessor :name, :value, :options, :type
+
+    TIME_TYPES = [Date, DateTime, Time].freeze
+    STRING_OR_TIME_TYPES = ([String] + TIME_TYPES).freeze
+
+    def initialize(name:, value:, options: {}, type: nil)
+      @name = name
+      @value = value
+      @options = options
+      @type = type
+    end
+
+    def should_set_default?
+      value.nil? && check_param_presence?(options[:default])
+    end
+
+    def set_default
+      self.value = options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+    end
+
+    def transform
+      self.value = options[:transform].to_proc.call(value)
+    end
+
+    def validate
+      Validator.new(self).validate!
+    end
+
+    private
+
+    def check_param_presence?(param)
+      !param.nil?
+    end
+  end
+end

data/lib/rails_simple_params/validator/blank.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Blank < Validator
+      def valid_value?
+        return false if parameter.options[:blank]
+
+        case value
+        when String
+          (/\S/ === value) # rubocop:disable Style/CaseEquality
+        when Array, Hash, ActionController::Parameters
+          !value.empty?
+        else
+          !value.nil?
+        end
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot be blank"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/custom.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Custom < Validator
+      def valid_value?
+        !options[:custom].call(value)
+      end
+
+      private
+
+      def error_message; end
+    end
+  end
+end

data/lib/rails_simple_params/validator/format.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Format < Validator
+      TIME_TYPES = [Date, DateTime, Time].freeze
+      STRING_OR_TIME_TYPES = ([String] + TIME_TYPES).freeze
+
+      def valid_value?
+        matches_time_types? || string_in_format?
+      end
+
+      private
+
+      def error_message
+        return "Parameter #{name} must be a string if using the format validation" unless matches_string_or_time_types?
+
+        "Parameter #{name} must match format #{options[:format]}" unless string_in_format?
+      end
+
+      def matches_time_types?
+        TIME_TYPES.any? { |cls| value.is_a? cls }
+      end
+
+      def matches_string_or_time_types?
+        STRING_OR_TIME_TYPES.any? { |cls| value.is_a? cls }
+      end
+
+      def string_in_format?
+        value =~ options[:format] && value.is_a?(String)
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/in.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class In < Validator
+      def valid_value?
+        value.nil? || case options[:in]
+                      when Range
+                        options[:in].include?(value)
+                      else
+                        Array(options[:in]).include?(value)
+                      end
+      end
+
+      private
+
+      def error_message
+        "Parameter #{parameter.name} must be within #{parameter.options[:in]}"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/is.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Is < Validator
+      def valid_value?
+        value === options[:is] # rubocop:disable Style/CaseEquality
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} must be #{options[:is]}"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/max.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Max < Validator
+      def valid_value?
+        value.nil? || options[:max] >= value
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot be greater than #{options[:max]}"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/max_length.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class MaxLength < Validator
+      def valid_value?
+        value.nil? || options[:max_length] >= value.length
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot have length greater than #{options[:max_length]}"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/min.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Min < Validator
+      def valid_value?
+        value.nil? || options[:min] <= value
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot be less than #{options[:min]}"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/min_length.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class MinLength < Validator
+      def valid_value?
+        value.nil? || options[:min_length] <= value.length
+      end
+
+      private
+
+      def error_message
+        "Parameter #{name} cannot have length less than #{options[:min_length]}"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator/required.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  class Validator
+    class Required < Validator
+      private
+
+      def valid_value?
+        !(value.nil? && options[:required])
+      end
+
+      def error_message
+        "Parameter #{name} is required"
+      end
+    end
+  end
+end

data/lib/rails_simple_params/validator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module RailsSimpleParams
+  class Validator
+    extend Forwardable
+
+    attr_reader :parameter
+
+    def_delegators :parameter, :name, :options, :value
+
+    VALIDATABLE_OPTIONS = %i[
+      blank
+      custom
+      format
+      in
+      is
+      max_length
+      max
+      min_length
+      min
+      required
+    ].freeze
+
+    def initialize(parameter)
+      @parameter = parameter
+    end
+
+    def validate!
+      options.each_key do |key|
+        next unless VALIDATABLE_OPTIONS.include? key
+
+        class_name = camelize(key)
+        Validator.const_get(class_name).new(parameter).valid!
+      end
+    end
+
+    def valid!
+      return if valid_value?
+
+      raise InvalidParameterError.new(
+        error_message,
+        param: name,
+        options: options
+      )
+    end
+
+    private
+
+    def camelize(term)
+      string = term.to_s
+      string.split('_').collect(&:capitalize).join
+    end
+
+    def error_message
+      nil
+    end
+
+    def valid_value?
+      # Should be overwritten in subclass
+      false
+    end
+  end
+end

data/lib/rails_simple_params/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsSimpleParams
+  VERSION = '1.4.0'
+end

data/lib/rails_simple_params.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'rails_simple_params/param'
+Dir[File.join(__dir__, 'rails_simple_params/validator', '*.rb')].each { |file| require file }
+Dir[File.join(__dir__, 'rails_simple_params/coercion', '*.rb')].reverse_each { |file| require file }
+Dir[File.join(__dir__, 'rails_simple_params', '*.rb')].each { |file| require file }
+
+ActiveSupport.on_load(:action_controller) do
+  include RailsSimpleParams
+end

metadata

@@ -0,0 +1,227 @@
+--- !ruby/object:Gem::Specification
+name: rails_simple_params
+version: !ruby/object:Gem::Version
+  version: 1.4.0
+platform: ruby
+authors:
+- Jeremy Weathers
+bindir: bin
+cert_chain: []
+date: 2025-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.1
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Simple DSL to validate params (and coerce them to the desired type) that
+  fall outside of Rails' default parameter whitelisting and ActiveModel validations
+  system. The common use cases are searching and sorting, whether from an HTML form
+  or via a JSON API.
+email:
+- jeremy@codekindly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rails_simple_params.rb
+- lib/rails_simple_params/coercion.rb
+- lib/rails_simple_params/coercion/array_param.rb
+- lib/rails_simple_params/coercion/big_decimal_param.rb
+- lib/rails_simple_params/coercion/boolean_param.rb
+- lib/rails_simple_params/coercion/float_param.rb
+- lib/rails_simple_params/coercion/hash_param.rb
+- lib/rails_simple_params/coercion/integer_param.rb
+- lib/rails_simple_params/coercion/string_param.rb
+- lib/rails_simple_params/coercion/time_param.rb
+- lib/rails_simple_params/coercion/virtual_param.rb
+- lib/rails_simple_params/invalid_parameter_error.rb
+- lib/rails_simple_params/param.rb
+- lib/rails_simple_params/param_evaluator.rb
+- lib/rails_simple_params/parameter.rb
+- lib/rails_simple_params/validator.rb
+- lib/rails_simple_params/validator/blank.rb
+- lib/rails_simple_params/validator/custom.rb
+- lib/rails_simple_params/validator/format.rb
+- lib/rails_simple_params/validator/in.rb
+- lib/rails_simple_params/validator/is.rb
+- lib/rails_simple_params/validator/max.rb
+- lib/rails_simple_params/validator/max_length.rb
+- lib/rails_simple_params/validator/min.rb
+- lib/rails_simple_params/validator/min_length.rb
+- lib/rails_simple_params/validator/required.rb
+- lib/rails_simple_params/version.rb
+homepage: http://github.com/jlw/rails-simple-param
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Parameter validation and type coercion for Rails
+test_files: []