rails_param 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79d1fa666d9f249c4e2758fff4fe24be7856eeb8
+  data.tar.gz: c65e6e4d12a12a57667c659157229da75b9ce6c9
+SHA512:
+  metadata.gz: a3c7b0fbafd0072dd049879f47b3c0d892411712dac4ca3c2a0d34d0221b42c5a40c90b732005998c3798920ec964b68961accfccabd3fb6996a88b77a331172
+  data.tar.gz: e0901f1e7eb5bb94f91480925f6b4876b63e3d85168159edf34c3fa4aec6fc98c137b89b7932825e2e323981b185351a17db70a87e56483464d964c26f9a9ab2

data/README.md

@@ -0,0 +1,92 @@
+# rails-param
+_Parameter Validation & Type Coercion for Rails_
+
+This is 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 (param! and one_of!) to indicate that they are destructive as they change the controller params object and may raise an exception.
+
+REST conventions take the guesswork out of designing and consuming web APIs. Simply `GET`, `POST`, `PATCH`, or `DELETE` resource endpoints, and you get what you'd expect.
+
+However, when it comes to figuring out what parameters are expected... well, all bets are off.
+
+This Rails extension takes a first step to solving this problem on the developer side
+
+**`rails-param` allows you to declare, validate, and transform endpoint parameters as you would in frameworks like [ActiveModel](http://rubydoc.info/gems/activemodel/3.2.3/frames) or [DataMapper](http://datamapper.org/).**
+
+> Use `rails-param` in combination with [`Rack::PostBodyContentTypeParser` and `Rack::NestedParams`](https://github.com/rack/rack-contrib) to automatically parameterize JSON `POST` bodies and nested parameters.
+
+## 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: ["ASC", "DESC"], transform: :upcase, default: "ASC"
+    param! :price,       String, format: "[<\=>]\s*\$\d+"
+
+    {...}
+  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`.
+
+- `String`
+- `Integer`
+- `Float`
+- `Boolean` _("1/0", "true/false", "t/f", "yes/no", "y/n")_
+- `Array` _("1,2,3,4,5")_
+- `Hash` _(key1:value1,key2:value2)_
+- `Date`, `Time`, & `DateTime`
+
+### Validations
+
+Encapsulate business logic in a consistent way with validations. If a parameter does not satisfy a particular condition, a `400` error is returned with a message explaining the failure.
+
+- `required`
+- `blank`
+- `is`
+- `in`, `within`, `range`
+- `min` / `max`
+- `format`
+
+### 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)}
+```
+
+## 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,110 @@
+module RailsParam
+  module Param
+
+    class InvalidParameterError < StandardError
+      attr_accessor :param, :options
+    end
+
+    def param!(name, type, options = {})
+      name = name.to_s
+
+      return unless params.member?(name) || options[:default].present? || options[:required]
+
+      begin
+        params[name] = coerce(params[name], type, options)
+        params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and options[:default]
+        params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform]
+        validate!(params[name], options)
+      # rescue InvalidParameterError => exception
+      #  if options[:raise]
+      #    exception.param, exception.options = name, options
+      #    raise exception
+      #  end
+
+      #  error = "Invalid Parameter: #{name}"
+      #  if content_type and content_type.match(mime_type(:json))
+      #    error = {message: error, errors: {name => exception.message}}.to_json
+      #  end
+
+      #  # do something with error object
+      end
+    end
+
+    # 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 coerce(param, type, options = {})
+      begin
+        return nil if param.nil?
+        return param if (param.is_a?(type) 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 : nil)) if type == TrueClass || type == FalseClass || type == Boolean
+        return nil
+      rescue ArgumentError
+        raise InvalidParameterError, "'#{param}' is not a valid #{type}"
+      end
+    end
+
+    def validate!(param, options)
+      options.each do |key, value|
+        case key
+        when :required
+          raise InvalidParameterError, "Parameter is required" if value && param.nil?
+        when :blank
+          raise InvalidParameterError, "Parameter 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 must be a string if using the format validation" unless param.kind_of?(String)
+          raise InvalidParameterError, "Parameter must match format #{value}" unless param =~ value
+        when :is
+          raise InvalidParameterError, "Parameter must be #{value}" unless param === value
+        when :in, :within, :range
+          raise InvalidParameterError, "Parameter 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 cannot be less than #{value}" unless param.nil? || value <= param
+        when :max
+          raise InvalidParameterError, "Parameter cannot be greater than #{value}" unless param.nil? || value >= param
+        when :min_length
+          raise InvalidParameterError, "Parameter cannot have length less than #{value}" unless param.nil? || value <= param.length
+        when :max_length
+          raise InvalidParameterError, "Parameter 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.0.1"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: rails_param
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nicolas Blanco
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: "\n    Parameter Validation & 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/nicolasblanco/rails_param
+licenses:
+- WTFPL
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Parameter Validation & Type Coercion for Rails
+test_files: []