rails_param2 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3712d8ce55990ec233da2ae2e2167bf23a8d9ebf
+  data.tar.gz: f057f82af9c4da204a379171663ae54c79e5d3f1
+SHA512:
+  metadata.gz: ec4cda59e7bdbdcd1ed5508e2cfd1536ac3db85aa5e8ebc21b253e189581e7d72eb8df813608bd3655103c2f306015f53a0a260c3c095f960473b5209f6551e3
+  data.tar.gz: 809d2c8687df17816e9f5a029b9330003731aced0d01d73f3cf2e73f06abb3e9b9ac15c57fb330ac9c26b18ce4546687f5f78ad1c38d717bb2b7ec1a05bc139f

data/README.md

@@ -0,0 +1,159 @@
+# rails_param2
+
+forked from [nicolasblanco/rails_param](https://github.com/nicolasblanco/rails_param)
+
+_Parameter Validation & Type Coercion for Rails_
+
+[![Build Status](https://travis-ci.org/nicolasblanco/rails_param.svg?branch=master)](https://travis-ci.org/nicolasblanco/rails_param)
+
+## 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 [this](http://blog.remarkablelabs.com/2012/12/activemodel-model-rails-4-countdown-to-2013) page to see an example on how to build a contact form using ActiveModel::Model.
+
+But sometimes, it’s not practical to create an external class just to validate and convert a few parameters. In this case, you may use this gem. It allows you to easily do validations and conversion of the parameters directly in your controller actions using a simple method call.
+
+## Credits
+
+This is originally a port of the gem [sinatra-param](https://github.com/mattt/sinatra-param) for the Rails framework.
+
+All the credits go to [@mattt](https://twitter.com/mattt).
+
+It has all the features of the sinatra-param gem, I used bang methods (like param!) to indicate that they are destructive as they change the controller params object and may raise an exception.
+
+## Installation
+
+As usual, in your Gemfile...
+
+``` ruby
+gem 'rails_param2'
+```
+
+## 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 (like 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, but this can but 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 (RailsParam::Param::InvalidParameterError) is raised.
+You may use the [rescue_from](http://api.rubyonrails.org/classes/ActiveSupport/Rescuable/ClassMethods.html#method-i-rescue_from) method in your controller to catch this kind of exception.
+
+- `required`
+- `blank`
+- `is`
+- `in`, `within`, `range`
+- `min` / `max`
+- `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 defined as either a default 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_param 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
+```
+
+## Thank you
+
+Many thanks to:
+
+* [Mattt Thompson (@mattt)](https://twitter.com/mattt)
+* [Vincent Ollivier (@vinc686)](https://twitter.com/vinc686)
+
+## Contact
+
+Nicolas Blanco
+
+- http://github.com/nicolasblanco
+- http://twitter.com/nblanco_fr
+- nicolas@nicolasblanco.fr
+
+## License
+
+rails-param is available under the MIT license. See the LICENSE file for more info.

data/lib/rails_param.rb

@@ -0,0 +1,5 @@
+require 'rails_param/param'
+
+ActiveSupport.on_load(:action_controller) do
+  include RailsParam::Param
+end

data/lib/rails_param/param.rb

@@ -0,0 +1,162 @@
+module RailsParam
+  module Param
+
+    DEFAULT_PRECISION = 14
+
+    class InvalidParameterError < StandardError
+      attr_accessor :param, :options
+
+      def message
+        return options[:message] if options.is_a?(Hash) && options.key?(:message)
+        super
+      end
+    end
+
+    class MockController
+      include RailsParam::Param
+      attr_accessor :params
+    end
+
+    def param!(name, type, options = {}, &block)
+      name = name.to_s unless name.is_a? Integer # keep index for validating elements
+
+      return unless params.include?(name) || check_param_presence?(options[:default]) || options[:required]
+
+      begin
+        params[name] = coerce(params[name], type, options)
+
+        # set default
+        if options[:default].respond_to?(:call)
+          params[name] = options[:default].call
+        elsif params[name].nil? && check_param_presence?(options[:default])
+          params[name] = options[:default]
+        end
+
+        # apply tranformation
+        if params[name] && options[:transform]
+          params[name] = options[:transform].to_proc.call(params[name])
+        end
+
+        # validate
+        validate!(params[name], name, options)
+
+        if block_given?
+          if type == Array
+            params[name].each_with_index do |element, i|
+              if element.is_a?(Hash) || element.is_a?(ActionController::Parameters)
+                recurse element, &block
+              else
+                params[name][i] = recurse({ i => element }, i, &block) # supply index as key unless value is hash
+              end
+            end
+          else
+            recurse params[name], &block
+          end
+        end
+        params[name]
+
+      rescue InvalidParameterError => exception
+        exception.param ||= name
+        exception.options ||= options
+        raise exception
+      end
+    end
+
+    # TODO: should we reintegrate this method?
+    # def one_of!(*names)
+    #   count = 0
+    #   names.each do |name|
+    #     if params[name] and params[name].present?
+    #       count += 1
+    #       next unless count > 1
+    #
+    #       error = "Parameters #{names.join(', ')} are mutually exclusive"
+    #       if content_type and content_type.match(mime_type(:json))
+    #         error = {message: error}.to_json
+    #       end
+    #
+    #       # do something with error object
+    #     end
+    #   end
+    # end
+
+    private
+
+    def check_param_presence? param
+      not param.nil?
+    end
+
+    def recurse(params, index = nil)
+      raise InvalidParameterError, 'no block given' unless block_given?
+      controller = RailsParam::Param::MockController.new
+      controller.params = params
+      yield(controller, index)
+    end
+
+    def coerce(param, type, options = {})
+      begin
+        return nil if param.nil?
+        return param if (param.is_a?(type) rescue false)
+        if (param.is_a?(Array) && type != Array) || ((param.is_a?(Hash) || param.is_a?(ActionController::Parameters)) && type != Hash)
+          raise InvalidParameterError, "'#{param}' is not a valid #{type}"
+        end
+        return param if (param.is_a?(ActionController::Parameters) && type == Hash rescue false)
+        return Integer(param) if type == Integer
+        return Float(param) if type == Float
+        return String(param) if type == String
+        return Date.parse(param) if type == Date
+        return Time.parse(param) if type == Time
+        return DateTime.parse(param) if type == DateTime
+        return Array(param.split(options[:delimiter] || ",")) if type == Array
+        return Hash[param.split(options[:delimiter] || ",").map { |c| c.split(options[:separator] || ":") }] if type == Hash
+        return (/^(false|f|no|n|0)$/i === param.to_s ? false : (/^(true|t|yes|y|1)$/i === param.to_s ? true : (raise ArgumentError))) if type == TrueClass || type == FalseClass || type == :boolean
+        if type == BigDecimal
+          param = param.delete('$,').strip.to_f if param.is_a?(String)
+          return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION))
+        end
+        return nil
+      rescue ArgumentError
+        raise InvalidParameterError, "'#{param}' is not a valid #{type}"
+      end
+    end
+
+    def validate!(param, param_name, options)
+      options.each do |key, value|
+        case key
+          when :required
+            raise InvalidParameterError, "Parameter #{param_name} is required" if value && param.nil?
+          when :blank
+            raise InvalidParameterError, "Parameter #{param_name} cannot be blank" if !value && case param
+                                                                                    when String
+                                                                                      !(/\S/ === param)
+                                                                                    when Array, Hash
+                                                                                      param.empty?
+                                                                                    else
+                                                                                      param.nil?
+                                                                                  end
+          when :format
+            raise InvalidParameterError, "Parameter #{param_name} must be a string if using the format validation" unless param.kind_of?(String)
+            raise InvalidParameterError, "Parameter #{param_name} must match format #{value}" unless param =~ value
+          when :is
+            raise InvalidParameterError, "Parameter #{param_name} must be #{value}" unless param === value
+          when :in, :within, :range
+            raise InvalidParameterError, "Parameter #{param_name} must be within #{value}" unless param.nil? || case value
+                                                                                                    when Range
+                                                                                                      value.include?(param)
+                                                                                                    else
+                                                                                                      Array(value).include?(param)
+                                                                                                  end
+          when :min
+            raise InvalidParameterError, "Parameter #{param_name} cannot be less than #{value}" unless param.nil? || value <= param
+          when :max
+            raise InvalidParameterError, "Parameter #{param_name} cannot be greater than #{value}" unless param.nil? || value >= param
+          when :min_length
+            raise InvalidParameterError, "Parameter #{param_name} cannot have length less than #{value}" unless param.nil? || value <= param.length
+          when :max_length
+            raise InvalidParameterError, "Parameter #{param_name} cannot have length greater than #{value}" unless param.nil? || value >= param.length
+        end
+      end
+    end
+
+  end
+end

data/lib/rails_param/version.rb

@@ -0,0 +1,3 @@
+module RailsParam #:nodoc
+  VERSION = "0.10.0"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: rails_param2
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Nicolas Blanco
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-20 00:00:00.000000000 Z
+dependencies:
+- !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: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: "\n    Parameter Validation and Type Coercion for Rails\n  "
+email: nicolas@nicolasblanco.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rails_param.rb
+- lib/rails_param/param.rb
+- lib/rails_param/version.rb
+homepage: http://github.com/shhavel/rails_param2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Parameter Validation and Type Coercion for Rails
+test_files: []