tainted_params 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65666fe19c54decad64747cd681f5c602abcdfec
+  data.tar.gz: ea37c8c5a85fdd7ded0a3d61bb9a86402d4dbd45
+SHA512:
+  metadata.gz: 634c472cb70888cd2fa94e0dd025494ef0d261efd19af819edab4652d5aef48c4234b76e683d53928545fa39317d9fdbc39dcf30f76021845462ded011d83b7c
+  data.tar.gz: 7d7f16e9d52012d4a92921421cb5ae37decf85225d72216ade98c87f7f5e0cdbbbbe5dd45420a9c392a633425978a68bc41c3e113dea3db82e7d125cf4f5a462

data/README.md

@@ -0,0 +1,83 @@
+# tainted_params
+
+https://github.com/Ragmaanir/tainted_params
+
+# DESCRIPTION
+
+Behaves like strong_parameters, with some minor differences.
+
+# FEATURES
+
+- Validate required and optional parameters
+- Validate their types
+- Type coercions for parameters
+
+# PROBLEMS/TODO
+
+- made some monkey patches to hash(slice, only, except, map_pairs) to not having to depend on active support gem
+- custom HashWithIndifferentAccess
+
+# SYNOPSIS
+
+    builder = TaintedParams::ParamsValidatorBuilder.new do
+      required :id, :Integer
+      optional :options, :Hash do
+        optional :name, :String
+        optional :active, :Boolean
+      end
+    end
+
+    validator = builder.result
+
+    result = validator.validate(options: { name: 'bob', active: 1, admin: true })
+
+    assert{ result.valid        == { options: { name: 'bob' } } }
+    assert{ result.invalid      == { options: { active: 1 } } }
+    assert{ result.unpermitted  == { options: { admin: true } } }
+    assert{ result.missing      == { id: nil } }
+
+# REQUIREMENTS
+
+* Ruby >= 2
+
+# INSTALL
+
+* FIX
+
+# DEVELOPERS
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+# INTERNALS
+
+The ParamsValidatorBuilder constructs a ParamsValidator out of ParamConstraints. The ParamsValidator contains the validation logic to split a params-hash into valid, invalid, missing and unpermitted parts.
+
+# LICENSE
+
+(The MIT License)
+
+Copyright (c) 2015 Ragmaanir
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/tainted_params/core_ext/hash.rb

@@ -0,0 +1,28 @@
+class Hash
+  def map_pairs
+    return enum_for(:map_pairs) unless block_given?
+
+    result = self.class.new
+    each do |key, value|
+      k, v = *yield(key, value)
+      result[k] = v
+    end
+    result
+  end
+
+  # def map_keys
+  #   map_pairs do |k, v|
+  #     [yield(k), v]
+  #   end
+  # end
+
+  def slice(keys)
+    select{ |k,_| keys.include?(k) }
+  end
+
+  alias_method :only, :slice
+
+  def except(keys)
+    select{ |k,_| !keys.include?(k) }
+  end
+end

data/lib/tainted_params/param_constraint.rb

@@ -0,0 +1,29 @@
+module TaintedParams
+
+  class ParamConstraint
+
+    attr_reader :name, :type, :nested
+
+    def initialize(name:, required:, type:, nested: nil)
+      raise ArgumentError unless type.is_a?(ParamTypeConstraint)
+
+      @name     = name || raise(ArgumentError)
+      @required = required
+      @type     = type
+      @nested   = nested
+    end
+
+    def required?
+      @required
+    end
+
+    def ==(other)
+      case other
+        when ParamConstraint then name == other.name
+        else false
+      end
+    end
+
+  end
+
+end

data/lib/tainted_params/param_type_constraint.rb

@@ -0,0 +1,56 @@
+module TaintedParams
+
+  class CoercionError < RuntimeError
+  end
+
+  class ParamTypeConstraint
+
+    attr_reader :types
+
+    def initialize(types)
+      raise(ArgumentError, "Invalid types: #{types.inspect}") unless types.is_a?(Array)
+      @types = types
+    end
+
+    def call(value)
+      if @types.any?{ |t| value.is_a?(t) }
+        value
+      else
+        :error
+      end
+    end
+
+  end
+
+  class CoercingParamTypeConstraint < ParamTypeConstraint
+
+    attr_reader :coercion
+
+    def initialize(type, coercion:)
+      super(type)
+      @coercion = coercion || raise(ArgumentError)
+    end
+
+    def call(value)
+      val = coercion.call(value)
+
+      super(val)
+    rescue CoercionError
+      :error
+    end
+
+  end
+
+  BOOLEAN_TYPE_CONSTRAINT = CoercingParamTypeConstraint.new([TrueClass, FalseClass], coercion: ->(val) {
+    case val
+      when true, *%w{true 1 yes} then true
+      when false, *%w{false 0 no} then false
+      else raise CoercionError
+    end
+  }).freeze
+
+  INTEGER_TYPE_CONSTRAINT = CoercingParamTypeConstraint.new([Integer], coercion: ->(val) {
+    Integer(val) rescue raise CoercionError
+  }).freeze
+
+end

data/lib/tainted_params/params_validator.rb

@@ -0,0 +1,67 @@
+module TaintedParams
+
+  class ValidationResult
+
+    attr_reader :valid, :invalid, :missing, :unpermitted
+
+    def initialize(valid:, invalid:, missing:, unpermitted:)
+      @valid = valid
+      @invalid = invalid
+      @missing = missing
+      @unpermitted = unpermitted
+    end
+
+  end
+
+  class ParamsValidator
+
+    def initialize(validations)
+      @validations = validations
+    end
+
+    def validate(params)
+      _validate(@validations, params)
+    end
+
+  private
+
+    def _validate(validations, params)
+      raise ArgumentError unless validations.is_a?(Array)
+      raise ArgumentError unless params.is_a?(Hash)
+
+      unpermitted = params.except(validations.map(&:name))
+      invalid     = {}
+      missing     = {}
+      valid       = {}
+
+      validations.each do |validation|
+
+        if v = params[validation.name]
+          res = validation.type.call(v)
+
+          if res == :error
+            invalid[validation.name] = v
+          elsif validation.nested
+            res = _validate(validation.nested, v)
+
+            valid[validation.name]        = res.valid unless res.valid.empty?
+            invalid[validation.name]      = res.invalid unless res.invalid.empty?
+            missing[validation.name]      = res.missing unless res.missing.empty?
+            unpermitted[validation.name]  = res.unpermitted unless res.unpermitted.empty?
+          else
+            valid[validation.name] = res
+          end
+        else
+          if validation.required?
+            missing[validation.name] = nil
+          end
+        end
+
+      end
+
+      ValidationResult.new(valid: valid, invalid: invalid, missing: missing, unpermitted: unpermitted)
+    end
+
+  end
+
+end

data/lib/tainted_params/params_validator_builder.rb

@@ -0,0 +1,53 @@
+module TaintedParams
+
+  DEFAULT_TYPE_CONSTRAINTS = {
+    :Boolean  => BOOLEAN_TYPE_CONSTRAINT,
+    :Integer  => INTEGER_TYPE_CONSTRAINT,
+    :Hash     => ParamTypeConstraint.new([Hash]),
+    :String   => ParamTypeConstraint.new([String])
+  }.freeze
+
+  class ParamsValidatorBuilder
+    def initialize(type_constraints = DEFAULT_TYPE_CONSTRAINTS, &block)
+      @type_constraints = type_constraints
+      @validations = []
+      @stack = [@validations]
+      instance_eval(&block)
+      @validations
+    end
+
+    def required(name, type, &block)
+      validation(name, true, type, &block)
+    end
+
+    def optional(name, type, &block)
+      validation(name, false, type, &block)
+    end
+
+    def validation(name, required, type, &block)
+      raise(ArgumentError, "Key registered twice: #{name}") if @stack.last.map(&:name).include?(name)
+
+      type_constraint = @type_constraints[type] || raise(ArgumentError, "Could not find constraint for type #{type.inspect}")
+      args = {name: name, type: type_constraint, required: required}
+
+      if block
+        nested = []
+        @stack.last << ParamConstraint.new(args.merge(nested: nested))
+        @stack << nested
+        instance_eval(&block)
+        @stack.pop
+      else
+        @stack.last << ParamConstraint.new(args)
+      end
+    end
+
+    def raw_validations
+      @validations
+    end
+
+    def result
+      ParamsValidator.new(@validations)
+    end
+  end
+
+end

data/lib/tainted_params/simple_key_hash.rb

@@ -0,0 +1,46 @@
+require 'delegate'
+
+module TaintedParams
+  class SimpleKeyHash < Hash#< SimpleDelegator
+
+    def self.stringify_keys(hash)
+      hash.map_pairs{ |k,v|
+        [k.to_s, v]
+      }
+    end
+
+    def initialize(hash)
+      raise ArgumentError unless hash.is_a?(Hash)
+      #super(self.class.stringify_keys(hash))
+      super()
+      update(self.class.stringify_keys(hash))
+    end
+
+    def default(key = nil)
+      case key
+        when String, nil then super
+        when Symbol then self[key.to_s]
+        else raise ArgumentError
+      end
+    end
+
+    # def fetch(key, *extras)
+    #   super(convert_key(key), *extras)
+    # end
+
+    # def values_at(*indices)
+    #   indices.collect { |key| self[convert_key(key)] }
+    # end
+
+  private
+
+    def convert_key(key)
+      case key
+        when Symbol then key.to_s
+        when String then key
+        else raise ArgumentError
+      end
+    end
+
+  end
+end

data/lib/tainted_params/string_key_hash.rb

@@ -0,0 +1,49 @@
+require 'delegate'
+require 'forwardable'
+
+module TaintedParams
+  class StringKeyHash# < SimpleDelegator
+    extend Forwardable
+    include Enumerable
+
+    def self.stringify_keys(hash)
+      hash.map_pairs{ |k,v|
+        [k.to_s, v]
+      }
+    end
+
+    def initialize(hash)
+      raise ArgumentError unless hash.is_a?(Hash)
+      @hash = self.class.stringify_keys(hash).freeze
+    end
+
+    def_delegators :@hash, :fetch, :each, :map_pairs, :values_at, :keys, :values
+
+    def [](key)
+      @hash[convert_key(key)]
+    end
+
+    def merge(hash, &block)
+      self.class.new(self.to_hash.merge(hash, &block))
+    end
+
+    def dup
+      self.class.new(self)
+    end
+
+    def to_hash
+      @hash
+    end
+
+  private
+
+    def convert_key(key)
+      case key
+        when Symbol then key.to_s
+        when String then key
+        else raise ArgumentError
+      end
+    end
+
+  end
+end

data/lib/tainted_params/version.rb

@@ -0,0 +1,3 @@
+module TaintedParams
+  VERSION = "0.3.1"
+end

data/lib/tainted_params.rb

@@ -0,0 +1,12 @@
+require 'tainted_params/version'
+require 'tainted_params/core_ext/hash'
+require 'tainted_params/string_key_hash'
+require 'tainted_params/simple_key_hash'
+require 'tainted_params/param_constraint'
+require 'tainted_params/param_type_constraint'
+require 'tainted_params/params_validator_builder'
+require 'tainted_params/params_validator'
+
+module TaintedParams
+
+end

data/spec/unit/coercing_param_type_constraint_spec.rb

@@ -0,0 +1,28 @@
+describe TaintedParams::CoercingParamTypeConstraint do
+
+  describe TaintedParams::INTEGER_TYPE_CONSTRAINT do
+    it 'attempts to convert strings to integers' do
+      c = TaintedParams::INTEGER_TYPE_CONSTRAINT
+
+      assert{ c.call('')      == :error }
+      assert{ c.call('-123')  == -123 }
+      assert{ c.call(123)     == 123 }
+    end
+  end
+
+  describe TaintedParams::BOOLEAN_TYPE_CONSTRAINT do
+    it 'attempts to convert strings to booleans' do
+      c = TaintedParams::BOOLEAN_TYPE_CONSTRAINT
+
+      assert{ c.call('')      == :error }
+      assert{ c.call('-123')  == :error }
+      assert{ c.call(123)     == :error }
+
+      assert{ c.call('yes')   == true }
+      assert{ c.call('1')     == true }
+      assert{ c.call('true')  == true }
+      assert{ c.call(true)    == true }
+    end
+  end
+
+end

data/spec/unit/param_type_constraint_spec.rb

@@ -0,0 +1,35 @@
+describe TaintedParams::ParamTypeConstraint do
+
+  it 'returns the value if it matches the String-type, :error otherwise' do
+    c = described_class.new([String])
+
+    assert{ c.call('') == '' }
+    assert{ c.call('some string') == 'some string' }
+    assert{ c.call(1) == :error }
+  end
+
+  it 'returns the value if it matches the Integer-type, :error otherwise' do
+    c = described_class.new([Integer])
+
+    assert{ c.call('') == :error }
+    assert{ c.call(1337) == 1337 }
+    assert{ c.call(1.337) == :error }
+  end
+
+  it 'returns the value if it matches Integer OF Float, :error otherwise' do
+    c = described_class.new([Integer, Float])
+
+    assert{ c.call('') == :error }
+    assert{ c.call(1337) == 1337 }
+    assert{ c.call(1.337) == 1.337 }
+  end
+
+  it 'returns the value if it is true or false, :error otherwise' do
+    c = described_class.new([TrueClass, FalseClass])
+
+    assert{ c.call(true) == true }
+    assert{ c.call(false) == false }
+    assert{ c.call(1) == :error }
+  end
+
+end

data/spec/unit/params_validator_builder_spec.rb

@@ -0,0 +1,25 @@
+describe TaintedParams::ParamsValidatorBuilder do
+
+  TC = TaintedParams::DEFAULT_TYPE_CONSTRAINTS
+
+  it 'constructs a tree out of constraints' do
+    b = described_class.new do
+      required :id, :Integer
+      optional :options, :Hash do
+        optional :name, :String
+        optional :active, :Boolean
+      end
+    end
+
+    result = [
+      TaintedParams::ParamConstraint.new(name: :id, type: TC[:Integer], required: true),
+      TaintedParams::ParamConstraint.new(name: :options, type: TC[:Hash], required: false, nested: [
+        TaintedParams::ParamConstraint.new(name: :name, type: TC[:String], required: false),
+        TaintedParams::ParamConstraint.new(name: :active, type: TC[:Boolean], required: false)
+      ])
+    ]
+
+    assert{ b.raw_validations == result }
+  end
+
+end

data/spec/unit/params_validator_spec.rb

@@ -0,0 +1,159 @@
+describe TaintedParams::ParamsValidator do
+
+  it 'puts valid params in the valid-hash' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      required :id, :Integer
+    end.result
+
+    res = val.validate(id: 1337)
+
+    assert{ res.valid       == {id: 1337} }
+    assert{ res.invalid     == {} }
+    assert{ res.missing     == {} }
+    assert{ res.unpermitted == {} }
+  end
+
+  it 'does type-coercion' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      required :id, :Integer
+    end.result
+
+    res = val.validate(id: '1337')
+
+    assert{ res.valid       == {id: 1337} }
+    assert{ res.invalid     == {} }
+    assert{ res.missing     == {} }
+    assert{ res.unpermitted == {} }
+  end
+
+  it 'puts invalid params in the invalid-hash' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      required :id, :Integer
+    end.result
+
+    res = val.validate(id: 'hundred')
+
+    assert{ res.valid       == {} }
+    assert{ res.invalid     == {id: 'hundred'} }
+    assert{ res.missing     == {} }
+    assert{ res.unpermitted == {} }
+  end
+
+  it 'puts missing params in the missing-hash' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      required :id, :Integer
+    end.result
+
+    res = val.validate({})
+
+    assert{ res.valid       == {} }
+    assert{ res.invalid     == {} }
+    assert{ res.missing     == {id: nil} }
+    assert{ res.unpermitted == {} }
+  end
+
+  it 'puts unpermitted params in the unpermitted-hash' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+    end.result
+
+    res = val.validate({unpermitted: 'test'})
+
+    assert{ res.valid       == {} }
+    assert{ res.invalid     == {} }
+    assert{ res.missing     == {} }
+    assert{ res.unpermitted == {unpermitted: 'test'} }
+  end
+
+  it 'does not require optional params' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      optional :id, :Integer
+    end.result
+
+    res = val.validate({})
+
+    assert{ res.valid       == { } }
+    assert{ res.invalid     == { } }
+    assert{ res.unpermitted == { } }
+    assert{ res.missing     == { } }
+  end
+
+  it 'does not validate hash-contents if not specified' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      optional :options, :Hash
+    end.result
+
+    res = val.validate(options: {anything: 123})
+
+    assert{ res.valid       == { options: { anything: 123 } } }
+    assert{ res.invalid     == { } }
+    assert{ res.unpermitted == { } }
+    assert{ res.missing     == { } }
+  end
+
+  it 'does validate sub-hashes if specified' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      optional :options, :Hash do
+        required :id, :Integer
+      end
+    end.result
+
+    res = val.validate(options: {id: 'lol'})
+
+    assert{ res.valid       == { } }
+    assert{ res.invalid     == { options: { id: 'lol' } } }
+    assert{ res.unpermitted == { } }
+    assert{ res.missing     == { } }
+  end
+
+  it 'does not require sub-hash if its optional but contains required params' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      optional :options, :Hash do
+        required :id, :Integer
+      end
+    end.result
+
+    res = val.validate({})
+
+    assert{ res.valid       == { } }
+    assert{ res.invalid     == { } }
+    assert{ res.unpermitted == { } }
+    assert{ res.missing     == { } }
+  end
+
+  it 'it puts valid, invalid, optional and missing params in sub-hashes in the result' do
+    val = TaintedParams::ParamsValidatorBuilder.new do
+      required :options, :Hash do
+        required :missing, :Integer
+        optional :valid, :Integer
+        optional :invalid, :String
+      end
+    end.result
+
+    res = val.validate({options: { valid: 1, invalid: 1, unpermitted: 1 } })
+
+    assert{ res.valid       == { options: { valid: 1 } } }
+    assert{ res.invalid     == { options: { invalid: 1 } } }
+    assert{ res.unpermitted == { options: { unpermitted: 1 } } }
+    assert{ res.missing     == { options: { missing: nil } } }
+  end
+
+  # it '' do
+  #   val = TaintedParams::ParamsValidatorBuilder.new do
+  #     required :id, :Integer
+  #     required :age, :Integer
+  #     required :secret, :String
+  #     permitted :options, :Hash do
+  #       permitted :name, :String
+  #       permitted :active, :Boolean
+  #     end
+  #   end.result
+
+  #   res = val.validate(id: 1337, age: 'lol', unpermitted: 1)
+
+  #   assert{ res.valid       == { id: 1337       } }
+  #   assert{ res.invalid     == { age: 'lol'     } }
+  #   assert{ res.unpermitted == { unpermitted: 1 } }
+  #   assert{ res.missing     == { secret: nil    } }
+  # end
+
+end

data/spec/unit/simple_key_hash_spec.rb

@@ -0,0 +1,9 @@
+describe TaintedParams::SimpleKeyHash do
+
+  it '' do
+    h = described_class.new(symbol: 1, 'string' => 2)
+    assert{ h['symbol'] == 1 }
+    assert{ h[:string] == 2 }
+  end
+
+end

data/spec/unit/string_key_hash_spec.rb

@@ -0,0 +1,19 @@
+describe TaintedParams::StringKeyHash do
+
+  let(:h) { described_class.new(symbol: 1, 'string' => 2) }
+
+  it '' do
+    assert{ h['symbol'] == 1 }
+    assert{ h[:string] == 2 }
+  end
+
+  it '' do
+    h2 = h.merge(newsymbol: 3)
+    assert{ h2['newsymbol'] == 3 }
+  end
+
+  it '' do
+    assert{ h.keys == ['symbol', 'string'] }
+  end
+
+end

data/spec/unit/tainted_params_spec.rb

@@ -0,0 +1,3 @@
+describe TaintedParams do
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: tainted_params
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Ragmaanir
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: wrong
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Similar to strong_parameters, but adds type validation and makes it possible
+  to retrieve the invalid or unpermitted parameters
+email:
+- ragmaanir@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/tainted_params.rb
+- lib/tainted_params/core_ext/hash.rb
+- lib/tainted_params/param_constraint.rb
+- lib/tainted_params/param_type_constraint.rb
+- lib/tainted_params/params_validator.rb
+- lib/tainted_params/params_validator_builder.rb
+- lib/tainted_params/simple_key_hash.rb
+- lib/tainted_params/string_key_hash.rb
+- lib/tainted_params/version.rb
+- spec/unit/coercing_param_type_constraint_spec.rb
+- spec/unit/param_type_constraint_spec.rb
+- spec/unit/params_validator_builder_spec.rb
+- spec/unit/params_validator_spec.rb
+- spec/unit/simple_key_hash_spec.rb
+- spec/unit/string_key_hash_spec.rb
+- spec/unit/tainted_params_spec.rb
+homepage: http://github.com/ragmaanir/tainted_params
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.2'
+requirements: []
+rubyforge_project: tainted_params
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Similar to strong_parameters, with some enhancements
+test_files:
+- spec/unit/simple_key_hash_spec.rb
+- spec/unit/tainted_params_spec.rb
+- spec/unit/string_key_hash_spec.rb
+- spec/unit/coercing_param_type_constraint_spec.rb
+- spec/unit/param_type_constraint_spec.rb
+- spec/unit/params_validator_spec.rb
+- spec/unit/params_validator_builder_spec.rb