stronger_parameters 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f1ac00b775682d4c9c6afb626ba93e34c5592d5
+  data.tar.gz: a91d5b4d4d1ca33e232b71761cfce8698f70e989
+SHA512:
+  metadata.gz: ddb1bc2266c76e9796903d0f5610878ab6435ae0a99191bebb94e462ecd710deb5b3c4ab3e5b6d5ee4c1101d124015102c9900eb21eceddd71e49a8f18c8b76a
+  data.tar.gz: f64f92a712ab52389c838315cc71dc6d9b3f292adfd9a8638213a6d84187762f5c2dd372e838c98a08dd38c7bd3564d45a19b9a98d5961138485bd341b481b48

data/README.md

@@ -0,0 +1,157 @@
+# stronger_parameters
+
+This is an extension of `strong_parameters` with added type checking.
+
+## Simple types
+You can specify simple types like this:
+
+```ruby
+params.permit(
+  :id   => Parameters.id,
+  :name => Parameters.string
+)
+```
+
+## Arrays
+You can specify arrays like this:
+
+```ruby
+params.permit(
+  :id => Parameters.array(Parameters.id)
+)
+```
+
+This will allow an array of id parameters that all are IDs.
+
+## Nested Parameters
+
+```ruby
+params.permit(
+  :name    => Parameters.string,
+  :emails  => Parameters.array(Parameters.string),
+  :friends => Parameters.array(
+    Parameters.map(
+      :name   => Parameters.string,
+      :family => Parameters.map(
+        :name => Parameters.string
+      )
+      :hobbies => Parameters.array(Parameters.string)
+    )
+  )
+)
+```
+
+This will allow parameters like this:
+
+```json
+{
+  "name": "Mick",
+  "emails": ["mick@zendesk.com", "mick@staugaard.com"],
+  "friends": [
+    {"name": "Morten", "family": {"name": "Primdahl"}, "hobbies": ["work", "art"]},
+    {"name": "Eric", "family": {"name": "Chapweske"}, "hobbies": ["boating", "whiskey"]}
+  ]
+}
+```
+
+### ActiveModel Nested Attributes
+
+```ruby
+params.require(:author).permit(
+  :name => Parameters.string,
+  :books_attributes => Parameters.array(
+    Parameters.map(
+      :title => Parameters.string,
+      :id => Parameters.id,
+      :_destroy => Parameters.boolean
+    )
+  )
+)
+```
+
+This will allow parameters like this:
+
+```json
+{
+  "author": {
+    "name": "Eric Chapweske",
+    "books_attributes": [
+      {"title": "Boatin' and Drinkin'", "id": 234, "_destroy": true},
+      {"title": "Advanced Boatin' and Drinkin'", "id": 567}
+    ]
+  }
+}
+```
+
+## Combining Requirements
+
+If you want to permit a parameter to be one of multiple types, you can use the `|` operator:
+
+```ruby
+params.require(:ticket).permit(
+  :status => Parameters.id | Parameters.enum('open', 'closed')
+)
+```
+
+This will allow these parameter sets:
+
+```json
+{
+  "ticket": {
+    "status": 123
+  }
+}
+```
+```json
+{
+  "ticket": {
+    "status": "open"
+  }
+}
+```
+
+You can use the `&` operator to apply further restrictions on the type:
+
+```ruby
+params.require(:user).permit(
+  :age => Parameters.integer & Parameters.gte(0)
+)
+```
+
+This requires the parameter to be an integer greater than or equal to 0.
+
+### Combining Requirements in Arrays
+
+You can also use the `|` and `&` operators in arrays:
+
+```ruby
+params.require(:group).permit(
+  :users => Parameters.array(Parameters.id | Parameters.string)
+)
+```
+
+This will permit these parameters:
+```json
+{
+  "group": {
+    "users": [123, "mick@zendesk.com", 345, 676, "morten@zendesk.com"]
+  }
+}
+```
+
+## Types
+
+| Syntax                         | (Simplified) Definition                                                 |
+|--------------------------------|-------------------------------------------------------------------------|
+| Parameters.string              | value.is_a?(String)                                                     |
+| Parameters.integer             | value.is_a?(Fixnum)                                                     |
+| Parameters.enum('asc', 'desc') | ['asc', 'desc'].include?(value)                                         |
+| Parameters.lt(10)              | value < 10                                                              |
+| Parameters.lte(10)             | value <= 10                                                             |
+| Parameters.gt(0)               | value > 0                                                               |
+| Parameters.gte(0)              | value >= 0                                                              |
+| Parameters.integer32           | Parameters.integer & Parameters.lte(2 ** 31) & Parameters.gte(-2 ** 31) |
+| Parameters.integer64           | Parameters.integer & Parameters.lte(2 ** 63) & Parameters.gte(-2 ** 63) |
+| Parameters.id                  | Parameters.integer & Parameters.lte(2 ** 31) & Parameters.gte(0)        |
+| Parameters.bigid               | Parameters.integer & Parameters.lte(2 ** 63) & Parameters.gte(0)        |
+| Parameters.boolean             | Parameters.enum(true, false, 'true', 'false', 1, 0)                     |

data/lib/stronger_parameters.rb

@@ -0,0 +1,6 @@
+require 'stronger_parameters/version'
+require 'action_pack'
+require 'strong_parameters' if ActionPack::VERSION::MAJOR == 3
+require 'stronger_parameters/railtie'
+require 'stronger_parameters/parameters'
+require 'stronger_parameters/constraints'

data/lib/stronger_parameters/constraints.rb

@@ -0,0 +1,84 @@
+require 'stronger_parameters/errors'
+
+module StrongerParameters
+  class Constraint
+    def value(v)
+      v
+    end
+
+    def |(other)
+      OrConstraint.new(self, other)
+    end
+
+    def &(other)
+      AndConstraint.new(self, other)
+    end
+
+    def ==(other)
+      self.class == other.class
+    end
+  end
+
+  class OrConstraint < Constraint
+    attr_reader :constraints
+
+    def initialize(*constraints)
+      @constraints = constraints
+    end
+
+    def value(v)
+      exception = nil
+
+      constraints.each do |c|
+        begin
+          return c.value(v)
+        rescue InvalidParameter => e
+          exception ||= e
+        end
+      end
+
+      raise exception
+    end
+
+    def |(other)
+      constraints << other
+      self
+    end
+
+    def ==(other)
+      super && constraints == other.constraints
+    end
+  end
+
+  class AndConstraint < Constraint
+    attr_reader :constraints
+
+    def initialize(*constraints)
+      @constraints = constraints
+    end
+
+    def value(v)
+      constraints.each do |c|
+        v = c.value(v)
+      end
+      v
+    end
+
+    def &(other)
+      constraints << other
+      self
+    end
+
+    def ==(other)
+      super && constraints == other.constraints
+    end
+  end
+end
+
+require 'stronger_parameters/constraints/string_constraint'
+require 'stronger_parameters/constraints/fixnum_constraint'
+require 'stronger_parameters/constraints/boolean_constraint'
+require 'stronger_parameters/constraints/array_constraint'
+require 'stronger_parameters/constraints/hash_constraint'
+require 'stronger_parameters/constraints/enumeration_constraint'
+require 'stronger_parameters/constraints/comparison_constraints'

data/lib/stronger_parameters/constraints/array_constraint.rb

@@ -0,0 +1,25 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class ArrayConstraint < Constraint
+    attr_reader :item_constraint
+
+    def initialize(item_constraint)
+      @item_constraint = item_constraint
+    end
+
+    def value(v)
+      if v.is_a?(Array)
+        return v.map do |item|
+          item_constraint.value(item)
+        end
+      end
+
+      raise InvalidParameter.new(v, "must be an array")
+    end
+
+    def ==(other)
+      super && item_constraint == other.item_constraint
+    end
+  end
+end

data/lib/stronger_parameters/constraints/boolean_constraint.rb

@@ -0,0 +1,20 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class BooleanConstraint < Constraint
+    TRUE_VALUES  = [true, 'true', '1', 1].freeze
+    FALSE_VALUES = [false, 'false', '0', 0].freeze
+
+    def value(v)
+      if TRUE_VALUES.include?(v)
+        return true
+      end
+
+      if FALSE_VALUES.include?(v)
+        return false
+      end
+
+      raise InvalidParameter.new(v, "must be either true or false")
+    end
+  end
+end

data/lib/stronger_parameters/constraints/comparison_constraints.rb

@@ -0,0 +1,47 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class ComparisonConstraints < Constraint
+    attr_reader :limit
+
+    def initialize(limit)
+      @limit = limit
+    end
+
+    def ==(other)
+      super && limit == other.limit
+    end
+  end
+
+  class LessThanConstraint < ComparisonConstraints
+    def value(v)
+      return v if v < limit
+
+      raise InvalidParameter.new(v, "must be less than #{limit}")
+    end
+  end
+
+  class LessThanOrEqualConstraint < ComparisonConstraints
+    def value(v)
+      return v if v <= limit
+
+      raise InvalidParameter.new(v, "must be less than or equal to #{limit}")
+    end
+  end
+
+  class GreaterThanConstraint < ComparisonConstraints
+    def value(v)
+      return v if v > limit
+
+      raise InvalidParameter.new(v, "must be greater than #{limit}")
+    end
+  end
+
+  class GreaterThanOrEqualConstraint < ComparisonConstraints
+    def value(v)
+      return v if v >= limit
+
+      raise InvalidParameter.new(v, "must be greater than or equal to #{limit}")
+    end
+  end
+end

data/lib/stronger_parameters/constraints/enumeration_constraint.rb

@@ -0,0 +1,21 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class EnumerationConstraint < Constraint
+    attr_reader :allowed
+
+    def initialize(*allowed)
+      @allowed = allowed
+    end
+
+    def value(v)
+      return v if allowed.include?(v)
+
+      raise InvalidParameter.new(v, "must be one of these: #{allowed.to_sentence}")
+    end
+
+    def ==(other)
+      super && allowed == other.allowed
+    end
+  end
+end

data/lib/stronger_parameters/constraints/fixnum_constraint.rb

@@ -0,0 +1,15 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class FixnumConstraint < Constraint
+    def value(v)
+      if v.is_a?(Fixnum)
+        return v
+      elsif v.is_a?(String) && v =~ /^\d+$/
+        return v.to_i
+      end
+
+      raise InvalidParameter.new(v, 'must be an integer')
+    end
+  end
+end

data/lib/stronger_parameters/constraints/hash_constraint.rb

@@ -0,0 +1,28 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class HashConstraint < Constraint
+    attr_reader :constraints
+
+    def initialize(constraints)
+      @constraints = constraints.with_indifferent_access
+    end
+
+    def value(v)
+      if v.is_a?(Hash)
+        return ActionController::Parameters.new(v).permit(constraints)
+      end
+
+      raise InvalidParameter.new(v, "must be a hash")
+    end
+
+    def merge(other)
+      other_constraints = other.is_a?(HashConstraint) ? other.constraints : other
+      self.class.new(constraints.merge(other_constraints))
+    end
+
+    def ==(other)
+      super && constraints == other.constraints
+    end
+  end
+end

data/lib/stronger_parameters/constraints/string_constraint.rb

@@ -0,0 +1,27 @@
+require 'stronger_parameters/constraints'
+
+module StrongerParameters
+  class StringConstraint < Constraint
+    attr_reader :maximum_length
+
+    def initialize(options = {})
+      @maximum_length = options[:maximum_length] || options[:max_length]
+    end
+
+    def value(v)
+      if v.is_a?(String)
+        if maximum_length && v.bytesize > maximum_length
+          raise InvalidParameter.new(v, "can not be longer than #{maximum_length} bytes")
+        end
+
+        return v
+      end
+
+      raise InvalidParameter.new(v, 'must be a string')
+    end
+
+    def ==(other)
+      super && maximum_length == other.maximum_length
+    end
+  end
+end

data/lib/stronger_parameters/errors.rb

@@ -0,0 +1,19 @@
+module StrongerParameters
+  class InvalidParameter < StandardError
+    attr_accessor :key, :value, :message
+
+    def initialize(value, message)
+      @value = value
+      @message = message
+      super(message)
+    end
+
+    def to_s
+      if key.present?
+        "found invalid value for #{key}. Value #{super}"
+      else
+        "found invalid value. Value #{super}"
+      end
+    end
+  end
+end

data/lib/stronger_parameters/parameters.rb

@@ -0,0 +1,136 @@
+require 'action_pack'
+
+if ActionPack::VERSION::MAJOR == 3
+  require 'action_controller/parameters'
+else
+  require 'action_controller/metal/strong_parameters'
+end
+
+require 'stronger_parameters/constraints'
+require 'stronger_parameters/errors'
+
+module StrongerParameters
+  module Parameters
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :hash_filter, :stronger_parameters
+      cattr_accessor :action_on_invalid_parameters, :instance_accessor => false
+    end
+
+    module ClassMethods
+      def anything
+        Constraint.new
+      end
+
+      def string(options = {})
+        StringConstraint.new(options)
+      end
+
+      def integer
+        @integer ||= FixnumConstraint.new
+      end
+
+      def lt(limit)
+        LessThanConstraint.new(limit)
+      end
+
+      def lte(limit)
+        LessThanOrEqualConstraint.new(limit)
+      end
+
+      def gt(limit)
+        GreaterThanConstraint.new(limit)
+      end
+
+      def gte(limit)
+        GreaterThanOrEqualConstraint.new(limit)
+      end
+
+      def integer32
+        integer & lte(2 ** 31) & gte(-2 ** 31)
+      end
+
+      def integer64
+        integer & lte(2 ** 63) & gte(-2 ** 63)
+      end
+
+      def id
+        integer & lte(2 ** 31) & gte(0)
+      end
+
+      def bigid
+        integer & lte(2 ** 63) & gte(0)
+      end
+
+      def enumeration(*allowed)
+        EnumerationConstraint.new(*allowed)
+      end
+      alias_method :enum, :enumeration
+
+      def boolean
+        BooleanConstraint.new
+      end
+
+      def array(item_constraint)
+        ArrayConstraint.new(item_constraint)
+      end
+
+      def map(constraints)
+        HashConstraint.new(constraints)
+      end
+    end
+
+    def hash_filter_with_stronger_parameters(params, filter)
+      stronger_filter = ActiveSupport::HashWithIndifferentAccess.new
+      other_filter    = ActiveSupport::HashWithIndifferentAccess.new
+
+      filter.each do |k,v|
+        if v.is_a?(Constraint)
+          stronger_filter[k] = v
+        else
+          other_filter[k] = v
+        end
+      end
+
+      hash_filter_without_stronger_parameters(params, other_filter)
+
+      slice(*stronger_filter.keys).each do |key, value|
+        if value.nil?
+          params[key] = nil
+          next
+        end
+
+        constraint = stronger_filter[key]
+        begin
+          params[key] = constraint.value(value)
+        rescue InvalidParameter => e
+          e.key = key
+
+          name = "invalid_parameter.action_controller"
+          ActiveSupport::Notifications.publish(name, :key => key, :value => value, :message => e.message)
+
+          params[key] = value
+
+          raise unless self.class.action_on_invalid_parameters == :log
+        end
+      end
+    end
+
+  end
+
+  module ControllerSupport
+    extend ActiveSupport::Concern
+
+    Parameters = ActionController::Parameters
+
+    included do
+      rescue_from(StrongerParameters::InvalidParameter) do |e|
+        render :text => "Invalid parameter: #{e.key} #{e.message}", :status => :bad_request
+      end
+    end
+  end
+end
+
+ActionController::Parameters.send :include, StrongerParameters::Parameters
+ActionController::Base.send :include, StrongerParameters::ControllerSupport

data/lib/stronger_parameters/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails/railtie'
+
+module StrongParameters
+  class Railtie < ::Rails::Railtie
+    initializer "stronger_parameters.config", :before => "action_controller.set_configs" do |app|
+      ActionController::Parameters.action_on_invalid_parameters = app.config.action_controller.delete(:action_on_invalid_parameters) do
+        (Rails.env.test? || Rails.env.development?) ? :log : false
+      end
+    end
+  end
+end

data/lib/stronger_parameters/version.rb

@@ -0,0 +1,3 @@
+module StrongerParameters
+  VERSION = '1.0.0'
+end

data/test/array_contraints_test.rb

@@ -0,0 +1,12 @@
+require_relative 'test_helper'
+
+describe 'array parameter constraints' do
+  subject { ActionController::Parameters.array(ActionController::Parameters.string) }
+
+  permits ['a', 'b']
+
+  rejects 'abc'
+  rejects 123
+  rejects [123, 456]
+  rejects ['abc', 123]
+end

data/test/boolean_constraints_test.rb

@@ -0,0 +1,17 @@
+require_relative 'test_helper'
+
+describe 'boolean parameter constraints' do
+  subject { ActionController::Parameters.boolean }
+
+  permits true,   :as => true
+  permits 'true', :as => true
+  permits 1,      :as => true
+  permits '1',    :as => true
+
+  permits false,   :as => false
+  permits 'false', :as => false
+  permits 0,       :as => false
+  permits '0',     :as => false
+
+  rejects 'foo'
+end

data/test/comparison_constraints_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+describe 'comparison parameter constraints' do
+  describe 'less-than types' do
+    subject { ActionController::Parameters.lt(2) }
+
+    permits 1
+    rejects 2
+    rejects 3
+  end
+
+  describe 'less-than-or-equal types' do
+    subject { ActionController::Parameters.lte(2) }
+
+    permits 1
+    permits 2
+    rejects 3
+  end
+
+  describe 'greater-than types' do
+    subject { ActionController::Parameters.gt(2) }
+
+    rejects 1
+    rejects 2
+    permits 3
+  end
+
+  describe 'greater-than-or-equal types' do
+    subject { ActionController::Parameters.gte(2) }
+
+    rejects 1
+    permits 2
+    permits 3
+  end
+end

data/test/controller_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class BooksController < ActionController::Base
+  def create
+    params.require(:book).permit(:id => Parameters.integer)
+
+    head :ok
+  end
+end
+
+describe BooksController do
+  it 'rejects invalid params' do
+    post :create, { :magazine => { :name => 'Mjallo!' } }
+    assert_response :bad_request
+    response.body.must_equal 'Required parameter missing: book'
+
+    post :create, { :book => { :id => 'Mjallo!' } }
+    assert_response :bad_request
+    response.body.must_equal 'Invalid parameter: id must be an integer'
+  end
+
+  it 'permits valid params' do
+    post :create, { :book => { :id => '123' } }
+    assert_response :ok
+  end
+end

data/test/enum_constraints_test.rb

@@ -0,0 +1,12 @@
+require_relative 'test_helper'
+
+describe 'enum parameter constraints' do
+  subject { ActionController::Parameters.enumeration('abc', 123) }
+
+  permits 'abc'
+  permits 123
+
+  rejects 'abcd'
+  rejects '123'
+  rejects 1234
+end

data/test/fixnum_constraints_test.rb

@@ -0,0 +1,13 @@
+require_relative 'test_helper'
+
+describe 'integer parameter constraints' do
+  subject { ActionController::Parameters.integer }
+
+  permits 123
+  permits '123', :as => 123
+
+  rejects 'abc'
+  rejects Date.today
+  rejects Time.now
+
+end

data/test/hash_constraint_test.rb

@@ -0,0 +1,28 @@
+require_relative 'test_helper'
+
+describe 'array parameter constraints' do
+  subject do
+    ActionController::Parameters.map(
+      :id => ActionController::Parameters.integer,
+      :name => ActionController::Parameters.string
+    )
+  end
+
+  def self.permits(value, options = {})
+    options[:as] ||= value
+    options[:as] = options[:as].with_indifferent_access
+
+    super(value, options)
+  end
+
+  permits(:id => 1, :name => 'Mick')
+  permits({:id => '1', :name => 'Mick'}, :as => {:id => 1, :name => 'Mick'})
+  permits(:id => 1)
+  permits({:id => '1'}, :as => {:id => 1})
+  permits(:name => 'Mick')
+
+  rejects(:id => 1, :name => 123)
+  rejects(:id => 'Mick', :name => 'Mick')
+  rejects(123)
+  rejects('abc')
+end

data/test/operator_constraints_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+describe 'operator parameter constraints' do
+  describe 'OR types' do
+    subject { ActionController::Parameters.integer | ActionController::Parameters.string }
+
+    permits 'abc'
+    permits '123', :as => 123
+
+    rejects Date.today
+    rejects Time.now
+  end
+
+  describe 'AND types' do
+    subject { ActionController::Parameters.string & ActionController::Parameters.integer }
+
+    permits '123', :as => 123
+
+    rejects 123
+    rejects 'abc'
+  end
+end

data/test/string_constraints_test.rb

@@ -0,0 +1,15 @@
+require_relative 'test_helper'
+
+describe 'string parameter constraints' do
+  subject { ActionController::Parameters.string }
+
+  permits 'abc'
+
+  rejects 123
+  rejects Date.today
+  rejects Time.now
+
+  it 'rejects strings that are too long' do
+    assert_rejects(:value) { params(:value => '123').permit(:value => ActionController::Parameters.string(:max_length => 2)) }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,72 @@
+ENV["RAILS_ENV"] = "test"
+
+require 'test/unit'
+require 'rails'
+require 'action_controller'
+require 'rails/test_help'
+
+class FakeApplication < Rails::Application; end
+
+Rails.application = FakeApplication
+Rails.configuration.action_controller = ActiveSupport::OrderedOptions.new
+Rails.configuration.secret_key_base = 'secret_key_base'
+
+require 'action_pack'
+require 'strong_parameters' if ActionPack::VERSION::MAJOR == 3
+
+module ActionController
+  SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
+  SharedTestRoutes.draw do
+    get ':controller(/:action)'
+    post ':controller(/:action)'
+    put ':controller(/:action)'
+    delete ':controller(/:action)'
+  end
+
+  class Base
+    include ActionController::Testing
+    include SharedTestRoutes.url_helpers
+
+    rescue_from(ActionController::ParameterMissing) do |e|
+      render :text => "Required parameter missing: #{e.param}", :status => :bad_request
+    end
+  end
+
+  class ActionController::TestCase
+    setup do
+      @routes = SharedTestRoutes
+    end
+  end
+end
+
+require 'stronger_parameters'
+require 'minitest/rails'
+require 'minitest/autorun'
+
+class MiniTest::Spec
+  def params(hash)
+    ActionController::Parameters.new(hash)
+  end
+
+  def assert_rejects(key, &block)
+    err = block.must_raise StrongerParameters::InvalidParameter
+    err.key.must_equal key.to_s
+  end
+
+  def self.permits(value, options = {})
+    type_casted = options.fetch(:as, value)
+
+    it "permits #{value.inspect} as #{type_casted.inspect}" do
+      permitted = params(:value => value).permit(:value => subject)
+      permitted[:value].must_equal type_casted
+    end
+  end
+
+  def self.rejects(value, options = {})
+    key = options.fetch(:key, :value)
+
+    it "rejects #{value.inspect}" do
+      assert_rejects(key) { params(:value => value).permit(:value => subject) }
+    end
+  end
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: stronger_parameters
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mick Staugaard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: minitest
+  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: guard
+  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: guard-minitest
+  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: minitest-rails
+  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: 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: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '2'
+description: 
+email:
+- mick@zendesk.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/stronger_parameters/constraints/array_constraint.rb
+- lib/stronger_parameters/constraints/boolean_constraint.rb
+- lib/stronger_parameters/constraints/comparison_constraints.rb
+- lib/stronger_parameters/constraints/enumeration_constraint.rb
+- lib/stronger_parameters/constraints/fixnum_constraint.rb
+- lib/stronger_parameters/constraints/hash_constraint.rb
+- lib/stronger_parameters/constraints/string_constraint.rb
+- lib/stronger_parameters/constraints.rb
+- lib/stronger_parameters/errors.rb
+- lib/stronger_parameters/parameters.rb
+- lib/stronger_parameters/railtie.rb
+- lib/stronger_parameters/version.rb
+- lib/stronger_parameters.rb
+- test/array_contraints_test.rb
+- test/boolean_constraints_test.rb
+- test/comparison_constraints_test.rb
+- test/controller_test.rb
+- test/enum_constraints_test.rb
+- test/fixnum_constraints_test.rb
+- test/hash_constraint_test.rb
+- test/operator_constraints_test.rb
+- test/string_constraints_test.rb
+- test/test_helper.rb
+- README.md
+homepage: https://github.com/zendesk/stronger_parameters
+licenses:
+- Apache License Version 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Type checking and type casting of parameters for Action Pack
+test_files:
+- test/array_contraints_test.rb
+- test/boolean_constraints_test.rb
+- test/comparison_constraints_test.rb
+- test/controller_test.rb
+- test/enum_constraints_test.rb
+- test/fixnum_constraints_test.rb
+- test/hash_constraint_test.rb
+- test/operator_constraints_test.rb
+- test/string_constraints_test.rb
+- test/test_helper.rb