has_strong_policy 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Fudgefile

@@ -0,0 +1,3 @@
+build :default do
+  task :rspec, :coverage => 100
+end

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in secures_params.gemspec
+gemspec
+
+gem 'rake'
+
+group :development, :test do
+  gem 'simplecov'
+  gem 'fudge'
+  gem 'rspec'
+  gem 'rb-fsevent'
+  gem 'guard-rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    has_strong_policy (0.0.1)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    coderay (1.0.8)
+    diff-lcs (1.1.3)
+    fudge (0.0.5)
+      activesupport
+      rainbow
+      thor
+    guard (1.6.1)
+      listen (>= 0.6.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-rspec (2.3.3)
+      guard (>= 1.1)
+      rspec (~> 2.11)
+    i18n (0.6.4)
+    listen (0.7.0)
+    lumberjack (1.0.2)
+    method_source (0.8.1)
+    multi_json (1.6.1)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rainbow (1.1.4)
+    rake (10.0.3)
+    rb-fsevent (0.9.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.3.3)
+    thor (0.16.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fudge
+  guard-rspec
+  has_strong_policy!
+  rake
+  rb-fsevent
+  rspec
+  simplecov

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jonathan Lozinski
+
+MIT License
+
+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/README.md

@@ -0,0 +1,125 @@
+[![Build Status](https://travis-ci.org/loz/has_strong_policy.png)](https://travis-ci.org/loz/has_strong_policy)
+[![Code Climate](https://codeclimate.com/github/loz/has_strong_policy.png)](https://codeclimate.com/github/loz/has_strong_policy)
+
+# HasStrongPolicy
+
+Simple delegation for your strong paramters
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'has_strong_policy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install has_strong_policy
+
+## Usage
+
+This gem provides a simple delgation framework for controllers and similar for
+using strong parameters in rails.  This allows:
+
+* Shared policy to be applied for multiple similar models (eg. STI)
+* Shared policy for the same model in different contexts (e.g. APIs)
+* More expressive declaration of paramter securing policies
+
+### Connecting your controller
+
+To use HasStrongPolicy in your rails controller, simply include it, and turn it on:
+
+
+```ruby
+class UserController < ApplicationController
+  include HasStrongPolicy::ControllerHelper
+
+  has_strong_policy
+end
+```
+
+This will provider automatic delgation to a conventionally named ParamsPolicy,
+in this case this would be the UserParamsPolicy.
+
+To access the params, simply use the `policy_params` helper, and you'll receive
+a clean param hash with all the policy already applied to strong params
+
+You can specify a specifc class to delegate security to by providing `:using`:
+
+
+```ruby
+class SettingsController < ApplicationController
+  include HasStrongPolicy::ControllerHelper
+
+  has_strong_policy :using => UserParamsPolicy
+end
+```
+
+#### Requesting the Params
+
+You request the params filtered through the policy using `policy_params` in
+place of regular `params`.  You can also supply options, like so:
+
+```ruby
+User.new(policy_params(:as => :admin))
+```
+
+### Defining your securing policy
+
+You can a plain old ruby object for your policy object, or use the given policy
+definition class to build expressive rulesets.
+
+#### Simple Ruby Interface
+
+Your ruby class should be named conventionally (unless you explicitly specify
+with `:using`.  The object simply needs to respond to `:apply` taking the
+rails params and an options hash.
+
+```ruby
+class UserParamsPolicy
+  def apply(params, options)
+    acceptable = [:email, :name]
+    if options[:role] == :admin
+      acceptable << :is_admin
+    end
+    params.require(:user).permit(acceptable)
+  end
+end
+```
+
+#### Using the Policy class and DSL:
+
+Secures Params provides a DSL based policy class which allows succinct definition
+of policies for defaults, specific actions or older accesible :as style roles:
+
+```ruby
+class UserParamsPolicy < HasStrongPolicy::Policy
+  policy do |p|
+    p.required :user
+    p.permitted :first_name, :last_name, :dob
+
+    p.on :create do |p|
+      p.permitted :email
+
+      p.as :admin do |p|
+        p.permitted :is_admin
+      end
+    end
+  end
+end
+```
+
+Sub definitions inherit the policy from prior ones.  So in the above case, user
+has name and dob permitted, but in the create action they can also set email.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+task :default do
+  exec 'fudge build'
+end

data/TODO

@@ -0,0 +1,14 @@
+TODO
+
+[ ] - possibly supply controller as :context for block evals?
+[ ] - nesting: p.secures :nested_attribute [, :using => :nested]
+
+Context stuff.. (passing controller for additional flexibility)
+
+with_context do |ctx|
+  if ctx.foo?
+    ...
+  else
+    ...
+  end
+end

data/has_strong_policy.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'has_strong_policy/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "has_strong_policy"
+  gem.version       = HasStrongPolicy::VERSION
+  gem.authors       = ["Jonathan Lozinski"]
+  gem.email         = ["jonathan.lozinski@gmail.com"]
+  gem.description   = %q{Simple params policy delegation for rails}
+  gem.summary       = %q{A simple delgation framework for strong parameters}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency 'activesupport'
+end

data/lib/has_strong_policy.rb

@@ -0,0 +1,8 @@
+require "has_strong_policy/version"
+
+module HasStrongPolicy
+  autoload :ControllerHelper, 'has_strong_policy/controller_helper'
+  autoload :Policy, 'has_strong_policy/policy'
+  autoload :PolicyDefinition, 'has_strong_policy/policy_definition'
+  autoload :PolicySet, 'has_strong_policy/policy_set'
+end

data/lib/has_strong_policy/controller_helper.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext'
+
+module HasStrongPolicy::ControllerHelper
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def has_strong_policy(options = {})
+      include HasStrongPolicy::ControllerHelper::HasHasStrongPolicy
+      @_policy_class = options[:using]
+    end
+  end
+
+  module HasHasStrongPolicy
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def policy_params
+      self.class.policy_class.new(params).apply
+    end
+
+    module ClassMethods
+      def policy_class
+        return @_policy_class if @_policy_class
+        name = self.name.gsub(/Controller/, '') + 'ParamsPolicy'
+        @_policy_class = name.constantize
+      end
+    end
+
+  end
+end

data/lib/has_strong_policy/policy.rb

@@ -0,0 +1,30 @@
+class HasStrongPolicy::Policy
+  def self.inherited(base)
+    base.instance_eval do
+      @policy_set = HasStrongPolicy::PolicySet.new
+
+      def policy_set
+        @policy_set
+      end
+    end
+  end
+
+  def self.policy(&block)
+    policy_set.with_condition({},nil,&block)
+  end
+
+  def apply(params, options = {})
+    conditions = build_conditions(params, options)
+    self.class.policy_set.with_condition(conditions).apply(params, options)
+  end
+
+  private
+
+  def build_conditions(params, options)
+    conditions = {}
+    conditions[:action] = params[:action] if params[:action]
+    conditions[:as] = options[:as] if options[:as]
+    conditions
+  end
+
+end

data/lib/has_strong_policy/policy_definition.rb

@@ -0,0 +1,34 @@
+class HasStrongPolicy::PolicyDefinition
+  def required(required)
+    @required = required
+  end
+
+  def permitted(*keys)
+    @permitted ||= []
+    @permitted += keys
+    @permitted.flatten!
+  end
+
+  def extend_from(target)
+    @required = target.get_required
+    @permitted = target.get_permitted
+  end
+
+  def apply(params, options = {})
+    applied = params
+    applied = applied.require(@required) if @required
+    applied = applied.permit(*@permitted) if @permitted
+    applied
+  end
+
+  protected
+
+  def get_permitted
+    @permitted
+  end
+
+  def get_required
+    @required
+  end
+
+end

data/lib/has_strong_policy/policy_set.rb

@@ -0,0 +1,54 @@
+class HasStrongPolicy::PolicySet
+  def initialize
+    @definitions = Hash.new do |h,k|
+      h[k] = HasStrongPolicy::PolicyDefinition.new
+    end
+  end
+
+  def with_condition(condition, parent = nil)
+    d = @definitions[condition]
+    d.extend_from(parent) if parent
+    proxy = Proxy.new(condition, self, d)
+    yield proxy if block_given?
+    proxy
+  end
+
+  class Proxy
+    attr_reader :conditions, :set, :definition
+
+    def initialize(conditions, set, definition)
+      @conditions = conditions
+      @definition = definition
+      @set = set
+    end
+
+    def apply(*args)
+      definition.apply(*args)
+    end
+
+    def required(*args)
+      definition.required(*args)
+    end
+
+    def permitted(*args)
+      definition.permitted(*args)
+    end
+
+    def on(action)
+      with_condition({:action => action}) do |definition|
+        yield definition
+      end
+    end
+
+    def as(role)
+      with_condition({:as => role}) do |definition|
+        yield definition
+      end
+    end
+
+    def with_condition(condition, &block)
+     set.with_condition(conditions.merge(condition), definition, &block)
+    end
+  end
+
+end

data/lib/has_strong_policy/version.rb

@@ -0,0 +1,3 @@
+module HasStrongPolicy
+  VERSION = "0.0.1"
+end

data/spec/lib/has_strong_policy/controller_helper_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module HasStrongPolicy
+
+  class ExampleController
+    include ::HasStrongPolicy::ControllerHelper
+
+    attr_accessor :params
+
+    def initialize(params = {})
+      @params = params
+    end
+  end
+
+  class XYZController < ExampleController; end
+  class XYZParamsPolicy; end
+  class FooParamsPolicy; end
+
+  describe ControllerHelper do
+
+    describe ".secures_params" do
+      let(:klass) { ExampleController.dup }
+      subject { klass.new }
+
+      it "adds a policy_params helper into the controller" do
+        subject.should_not respond_to :policy_params
+        klass.has_strong_policy
+        subject.should respond_to :policy_params
+      end
+
+      context "when provided :using => " do
+        before :each do
+          klass.has_strong_policy :using => FooParamsPolicy
+        end
+
+        it "uses named constant as the securing class" do
+          klass.policy_class.should == FooParamsPolicy
+        end
+      end
+    end
+
+    describe "#policy_params" do
+      let(:klass) { XYZController }
+
+      subject { klass.new({:example => :params})}
+
+      before :each do
+        klass.has_strong_policy
+      end
+
+      it "returns params processed through XYZParamsPolicy for XYZController" do
+        policy = stub
+        XYZParamsPolicy.should_receive(:new).with(subject.params).and_return(policy)
+        policy.should_receive(:apply).and_return({:policy => :params})
+        subject.policy_params.should == {:policy => :params}
+      end
+    end
+  end
+end

data/spec/lib/has_strong_policy/policy_definition_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe HasStrongPolicy::PolicyDefinition do
+  describe "required" do
+    it "adds a required constraint to be applied" do
+      subject.required :foo
+      params = mock
+
+      params.should_receive(:require).with(:foo).and_return(:applied)
+
+      subject.apply(params).should == :applied
+    end
+  end
+
+  describe "permitted" do
+    it "adds a permitted constraint to be applied" do
+      subject.permitted :foo, :bar
+      params = mock
+
+      params.should_receive(:permit).with(:foo, :bar).and_return(:permitted)
+      subject.apply(params).should == :permitted
+    end
+
+    it "appends new directives" do
+      subject.permitted :foo, :bar
+      subject.permitted :baz
+      params = mock
+
+      params.should_receive(:permit).with(:foo, :bar, :baz).and_return(:permitted)
+      subject.apply(params).should == :permitted
+    end
+  end
+
+  describe "extend_from" do
+    it "copies the directives of the target" do
+      target = described_class.new
+      target.required :foo
+      target.permitted :bar
+
+      subject.extend_from(target)
+      subject.permitted :baz
+
+      params = mock
+      required = mock
+
+      params.should_receive(:require).with(:foo).and_return(required)
+      required.should_receive(:permit).with(:bar, :baz).and_return(:extended)
+
+      subject.apply(params).should == :extended
+    end
+  end
+end

data/spec/lib/has_strong_policy/policy_set_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module HasStrongPolicy
+  describe PolicySet do
+    describe "#with_condition" do
+      it "returns the definition for given condition" do
+        subject.with_condition(:foo => :base).should respond_to :apply
+
+        subject.with_condition(:foo => :bar).definition.should ==
+          subject.with_condition(:foo => :bar).definition
+
+        subject.with_condition(:foo => :bar).definition.should_not ==
+          subject.with_condition(:bar => :baz).definition
+      end
+
+      context "with a block" do
+        it "yields the definition" do
+          definition = nil
+          subject.with_condition :foo => :bar do |d|
+            definition = d.definition
+          end
+
+          subject.with_condition(:foo => :bar).definition.should == definition
+        end
+
+        it "delegates to the definition" do
+          proxy = nil
+          subject.with_condition :foo => :bar do |d|
+            proxy = d
+          end
+          defn = mock
+          proxy.stub(:definition).and_return(defn)
+          defn.should_receive(:apply)
+          defn.should_receive(:required)
+          defn.should_receive(:permitted)
+          proxy.apply(:foo)
+          proxy.required(:foo)
+          proxy.permitted(:foo)
+        end
+
+        it "supports nesting conditions" do
+          nested = nil
+          subject.with_condition :foo => :bar do |d|
+            d.with_condition :bar => :baz do |n|
+              nested = n
+            end
+          end
+
+          expected = nested.definition
+          actual = subject.with_condition(:foo => :bar, :bar => :baz).definition
+
+          expected.should == actual
+        end
+      end
+    end
+  end
+end

data/spec/lib/has_strong_policy/policy_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+module HasStrongPolicy
+
+  class ExamplePolicy < Policy
+  end
+
+  class AnotherPolicy < Policy
+  end
+
+  describe Policy do
+    let(:params) do
+      MockStrongParams.new({
+        :user => {
+          :name => 'Joe Bloggs',
+          :email => 'joe@bloggs.com',
+          :age => 21,
+          :phone => '12345',
+          :role => 'admin'
+        },
+        :foo => {
+          :something => 'bar'
+        }
+      })
+    end
+
+    let(:klass) { ExamplePolicy.dup }
+    subject { klass.new }
+
+    it "has unique policy for each subclass" do
+      klass1 = ExamplePolicy.dup
+      klass2 = AnotherPolicy.dup
+      klass1.policy do |p|
+        p.required :user
+      end
+      klass2.policy do |p|
+        p.required :foo
+      end
+
+      first = klass1.new
+      second = klass2.new
+
+      first.apply(params).to_hash.should_not == second.apply(params).to_hash
+    end
+
+    describe "Defining default policy" do
+
+      before :each do
+        klass.policy do |p|
+          p.required :user
+          p.permitted :name, :age, :phone
+        end
+      end
+
+      it "is applied to result set" do
+        applied = subject.apply(params)
+        applied.to_hash.should == {
+          :name => 'Joe Bloggs',
+          :age => 21,
+          :phone => '12345'
+        }
+        applied.should be_permitted
+      end
+    end
+
+    describe "Conditional Policies" do
+      describe "on" do
+        before :each do
+          klass.policy do |p|
+            p.required :user
+            p.permitted :name, :age, :phone
+
+            p.on :create do |d|
+              d.permitted :email
+            end
+          end
+          params[:action] = :create
+        end
+
+        it "is applied when action is in params" do
+          applied = subject.apply(params)
+          applied[:email].should == 'joe@bloggs.com'
+        end
+
+        #This not working causes failure above too :(
+        it "inherits prior conditions" do
+          applied = subject.apply(params)
+          applied[:name].should == 'Joe Bloggs'
+          applied[:phone].should == '12345'
+        end
+
+        it "does not apply when action does not match" do
+          params[:action] = :foo
+          applied = subject.apply(params)
+
+          applied[:email].should be_nil
+        end
+      end
+
+      describe "as" do
+        before :each do
+          klass.policy do |p|
+            p.required :user
+            p.permitted :name, :age, :phone
+
+            p.as :admin do |d|
+              d.permitted :role
+            end
+          end
+        end
+
+        it "is applied when an :as => :role option is supplied" do
+          applied = subject.apply(params, :as => :admin)
+          applied[:role].should == 'admin'
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'simplecov'
+SimpleCov.start
+
+require 'has_strong_policy'
+
+require File.expand_path("../support/mock_strong_params", __FILE__)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/strong_param_interface_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "The Interface for Strong Params" do
+  let(:params) do
+    MockStrongParams.new({
+      :user => {
+        :name => "Joe Bloggs",
+        :age => 21,
+        :phone => "12345",
+        :email => "joe@bloggs.com"
+      },
+      :foo => {
+    }
+    })
+  end
+
+  it "does require" do
+    params.require(:user)[:name].should == 'Joe Bloggs'
+    params.require(:foo).should_not be_permitted
+
+    expect { params.require(:not_present) }.to raise_error
+  end
+
+  it "does permit" do
+    perm = params.require(:user).permit(:name, :age)
+    perm.should be_permitted
+    perm[:name].should == 'Joe Bloggs'
+    perm[:age].should == 21
+    perm[:email].should be_nil
+  end
+end

data/spec/support/mock_strong_params.rb

@@ -0,0 +1,36 @@
+class MockStrongParams
+  #For Test
+  attr_writer :permitted
+  def initialize(params = {})
+    @params = params
+  end
+
+  def [](key)
+    @params[key]
+  end
+
+  def []=(key, value)
+    @params[key] = value
+  end
+
+  def to_hash
+    @params
+  end
+
+  #API
+  def require(key)
+    found = @params.fetch(key) { raise 'RequiredMissing' }
+    self.class.new found
+  end
+
+  def permit(*keys)
+    permitted = self.class.new(@params.select {|k,v| keys.include? k})
+    permitted.permitted = true
+    permitted
+  end
+
+  def permitted?
+    @permitted
+  end
+end
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: has_strong_policy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Lozinski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple params policy delegation for rails
+email:
+- jonathan.lozinski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Fudgefile
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- has_strong_policy.gemspec
+- lib/has_strong_policy.rb
+- lib/has_strong_policy/controller_helper.rb
+- lib/has_strong_policy/policy.rb
+- lib/has_strong_policy/policy_definition.rb
+- lib/has_strong_policy/policy_set.rb
+- lib/has_strong_policy/version.rb
+- spec/lib/has_strong_policy/controller_helper_spec.rb
+- spec/lib/has_strong_policy/policy_definition_spec.rb
+- spec/lib/has_strong_policy/policy_set_spec.rb
+- spec/lib/has_strong_policy/policy_spec.rb
+- spec/spec_helper.rb
+- spec/strong_param_interface_spec.rb
+- spec/support/mock_strong_params.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2612279817966036190
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2612279817966036190
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple delgation framework for strong parameters
+test_files:
+- spec/lib/has_strong_policy/controller_helper_spec.rb
+- spec/lib/has_strong_policy/policy_definition_spec.rb
+- spec/lib/has_strong_policy/policy_set_spec.rb
+- spec/lib/has_strong_policy/policy_spec.rb
+- spec/spec_helper.rb
+- spec/strong_param_interface_spec.rb
+- spec/support/mock_strong_params.rb