shields_up 0.17.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 391eded2ca4d95f1777b8a227f13905e7f01b975
+  data.tar.gz: 05c2a17280fb9c761b3743e688abcc3c9cbe97ce
+SHA512:
+  metadata.gz: a13deb71b95918e3c1b7d297ec5f72a9d8b29a71d9a58c8f3259d09d9d8373aa2c6f7881b9f7c0c2c0b0df01adcd0f6f052383454ec527c2ac061faf045830a1
+  data.tar.gz: 4d99e218185e1db2828543e5c9ce39f469c593a9cc0a16c98516e1625ffe7d903acb7bf895c2b81ac830c85b49137aaf19d5562bf0bb785de84549da3a8732fd

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'mocha'
+gem 'activemodel'
+gem 'rails'
+gem 'minitest', '~> 4.0'
+gem "codeclimate-test-reporter", :require => nil

data/Gemfile.lock

@@ -0,0 +1,108 @@
+PATH
+  remote: .
+  specs:
+    shields_up (0.16.0)
+      activesupport (~> 3.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.2.19)
+      actionpack (= 3.2.19)
+      mail (~> 2.5.4)
+    actionpack (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+    activerecord (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+    activesupport (3.2.19)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    codeclimate-test-reporter (0.4.1)
+      simplecov (>= 0.7.1, < 1.0.0)
+    docile (1.1.5)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.9)
+    journey (1.0.4)
+    json (1.8.1)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    metaclass (0.0.4)
+    mime-types (1.25.1)
+    minitest (4.7.5)
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.10.1)
+    polyglot (0.3.5)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.4)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.19)
+      actionmailer (= 3.2.19)
+      actionpack (= 3.2.19)
+      activerecord (= 3.2.19)
+      activeresource (= 3.2.19)
+      activesupport (= 3.2.19)
+      bundler (~> 1.0)
+      railties (= 3.2.19)
+    railties (3.2.19)
+      actionpack (= 3.2.19)
+      activesupport (= 3.2.19)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.3.2)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.19.1)
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.41)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel
+  codeclimate-test-reporter
+  minitest (~> 4.0)
+  mocha
+  rails
+  shields_up!

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Appfolio Inc.
+
+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,107 @@
+[![Build Status](https://travis-ci.org/appfolio/shields_up.png)](https://travis-ci.org/appfolio/shields_up)
+[![Code Climate](https://codeclimate.com/github/appfolio/shields_up/badges/gpa.svg)](https://codeclimate.com/github/appfolio/shields_up)
+[![Test Coverage](https://codeclimate.com/github/appfolio/shields_up/badges/coverage.svg)](https://codeclimate.com/github/appfolio/shields_up)
+
+#Shields Up
+This gem provides an alternative implementation of strong_parameters.
+##usage (the grammar for permit statements is the same as strong_parameters)
+- **Read this first**: [Strong Parameter Usage](http://edgeguides.rubyonrails.org/action_controller_overview.html#strong-parameters)
+
+
+##Differences to strong parameter
+params.symbolize_keys (or similar functions) will disable strong_parameters
+protection silently. With ShieldsUp this can not happen.
+
+## Enable ShieldsUp<br>
+
+in Gemfile<br>
+```
+  gem 'shields_up'
+```
+in controllers<br>
+```
+  include ShieldsUp
+```
+
+- ShieldsUp::Parameter type only allows three operations: [], permit and require.
+- You can use symbols or strings to access variables.<br>
+
+##Example:<br>
+```
+params[:company]
+```
+not:
+```
+params["company"]
+```
+or
+```
+params.fetch(:company)
+params.fetch("company")
+```
+
+##A more complicated example:<br>
+```
+params.permit(:company => [:address, :enabled])
+```
+not:
+```
+params.permit("company" => [:address, "enabled"])
+```
+
+## How to disable shields up.<br>
+If you have a bunch of legacy code in a controller or you call into gems whose
+parameter handling
+you do not control (e.g. devise) you can disable shields_up at your own risk.
+Similar to holding a lock around critical sections these blocks should generally be kept as short as possible.
+<pre>
+params.with_shields_down do
+  call_some_legacy_stuff_or_gem()
+end
+</pre>
+<br>
+- with_shields_down can not be nested. This means inside with_shields_down there should be no with_shields_down
+- the places in an application disabling parameter protection are such explicit and can be accounted for during an audit
+</b>
+
+##Common Pitfalls:
+- *to update and destroy associated records, permit <i>:id,</i> and <i> :_destroy </i> when you use accepts_nested_attributes_for in combination with a has_many association. <br>
+
+Example:
+```
+# To whitelist the following data:
+# {"applicant" => {"email_address" => "some@email.com",
+#                  "contact_info_attributes" => { "1" => {"salutation" => "First Salutation"},
+#                                        "2" => {"salutation" => "Second Salutation"}}}}
+    params.permit(
+        {:applicant => [
+            :email_address,
+            {:contact_info_attributes => [:salutation, :id, :_destroy]},
+        ]}
+    )
+```
+- *use hash inside permit statment** for non scaler type.<br>
+
+Example:
+```
+# To whitelist the following data:
+# {"applicant" => {"email_address" => "some@email.com",
+#                  "info" => { "first_name" => 'First', "last_name" => 'Last'}}}
+```
+<pre>
+    params.permit(
+        {:applicant => [
+            :email_address,
+            <b>{</b>:info => [:first_name, :last_name]<b>}</b>
+        ]}
+    )
+</pre>
+
+##Limitations
+Similar to strong_parameters, this gem was designed with the most common use cases in mind. It is not meant as a silver bullet to handle all your whitelisting problems. However you can easily disable shields_up, and sanitize the parameter with your own code to adapt to your situation.<br>
+
+In order to keep our grammar compatible to strong_parameters it is not possible
+to express permission for array of arrays:
+```
+{'company' => [['a','b'],['a','b']]}
+```

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts 'Run `bundle install` to install missing gems'
+  exit e.status_code
+end
+
+require 'rake'
+require 'rake/testtask'
+
+namespace :test do
+  Rake::TestTask.new(:all) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/shields_up/**/*_test.rb'
+    test.verbose = true
+  end
+end
+
+task :default => 'test:all'

data/lib/shields_up/exceptions.rb

@@ -0,0 +1,4 @@
+module ShieldsUp
+  class ParameterMissing < RuntimeError; end
+  class UnsupportedParameterType < RuntimeError; end
+end

data/lib/shields_up/parameters.rb

@@ -0,0 +1,158 @@
+require 'active_support/core_ext/hash/indifferent_access'
+module ShieldsUp
+  class Parameters
+    if defined?(ActionController) && defined?(ActionController::Parameters)
+      PARAM_TYPE = ActionController::Parameters
+    else
+      PARAM_TYPE = ActiveSupport::HashWithIndifferentAccess
+    end
+
+    PERMITTED_SCALAR_TYPES = [
+        String,
+        Symbol,
+        NilClass,
+        Numeric,
+        TrueClass,
+        FalseClass,
+        Date,
+        Time,
+        # DateTimes are Dates, we document the type but avoid the redundant check.
+        StringIO,
+        IO,
+    ]
+    if defined?(ActionDispatch) && defined?(ActionDispatch::Http) && defined?(ActionDispatch::Http::UploadedFile)
+      PERMITTED_SCALAR_TYPES << ActionDispatch::Http::UploadedFile
+    end
+    if defined?(Rack) && defined?(Rack::Test) && defined?(Rack::Test::UploadedFile)
+      PERMITTED_SCALAR_TYPES << Rack::Test::UploadedFile
+    end
+
+    def with_shields_down
+      saved = @controller.params
+      @controller.params = @original_params
+      yield
+    ensure
+      @controller.params = saved
+    end
+
+    def initialize(params, controller)
+      raise UnsupportedParameterType.new unless params.is_a? ActiveSupport::HashWithIndifferentAccess
+      @original_params = params
+      @controller = controller
+      @params = deep_dup_to_hash(params)
+    end
+
+    def to_s
+      @params.inspect
+    end
+
+    def permit(*permissions)
+      {}.tap do |permitted|
+        permissions.each do |permission|
+          permission, key = (permission.is_a?(Symbol) || permission.is_a?(String)) ? [permission, permission.to_s] : [permission.values.first, permission.keys.first.to_s]
+          if @params.has_key?(key)
+            if permission.is_a?(Symbol) || permission.is_a?(String)
+                result = permit_scalar(key)
+                permitted[key] = result if @params[key] == result
+            else
+              result = permit_nested(key, permission)
+              permitted[key] = result if result
+            end
+          end
+        end
+      end.symbolize_keys
+    end
+
+    def require(key)
+      self[key] or raise ParameterMissing.new("Required parameter #{key} does not exist in #{to_s}")
+    end
+
+    # def permit!
+    #   deep_dup_to_hash(@params).symbolize_keys
+    # end
+
+    def [](key)
+      key = key.to_s
+      value = @params[key]
+      if value.is_a?(Hash)
+        self.class.new(@original_params[key], @controller)
+      elsif value.is_a?(Array)
+        [].tap do |array|
+          value.each_with_index do |element, i|
+            if permitted_scalar?(element)
+              array << element
+            elsif element.is_a? Hash
+              array << self.class.new(@original_params[key][i], @controller)
+            end
+          end
+        end
+      else
+        permit_scalar(key)
+      end
+    end
+
+  private
+
+    def permit_scalar(key)
+      permitted_scalar?(@params[key]) ? @params[key] : nil
+    end
+
+    def permit_simple_hash(name, permissions)
+      if @params[name].is_a? Hash
+        self.class.new(@original_params[name], @controller).permit(*permissions)
+      else
+        permit_scalar(name)
+      end
+    end
+
+    def permit_nested_attributes_for(name, permissions)
+      {}.tap do |result|
+        @params[name].each do |key, value|
+          result[key] = self.class.new(@original_params[name][key], @controller).permit(*permissions) if value.is_a? Hash
+          result[key] = value if permitted_scalar?(value)
+        end
+      end
+    end
+
+    def permit_array_of_hashes(name, permissions)
+      @params[name].zip(@original_params[name]).select{|el| el[0].is_a? Hash}.collect{|el| self.class.new(el[1], @controller).permit(*permissions)}
+    end
+
+    def permit_scalars(name)
+      @params[name].select { |element| permitted_scalar? element }
+    end
+
+    def integer_key?(k)
+      k =~ /\A-?\d+\z/
+    end
+
+    def permit_nested(nested_name, permissions_for_nested)
+      if permissions_for_nested == [] # Declaration {:comment_ids => []}.
+        @params[nested_name].is_a?(Array) ? permit_scalars(nested_name) : nil
+      elsif @params[nested_name].is_a? Array # Declaration {:user => :name} or {:user => [:name, :age, {:adress => ...}]}.
+        permit_array_of_hashes(nested_name, permissions_for_nested)
+      elsif @params[nested_name].is_a?(Hash) && @params[nested_name].keys.all? { |k| integer_key?(k) } #{ '1' => {'title' => 'First Chapter'}, '2' => {'title' => 'Second Chapter'}}
+        permit_nested_attributes_for(nested_name, permissions_for_nested)
+      else
+        permit_simple_hash(nested_name, permissions_for_nested)
+      end
+    end
+
+    def permitted_scalar?(value)
+      PERMITTED_SCALAR_TYPES.any? {|type| value.is_a?(type)}
+    end
+
+    def deep_dup_to_hash(params)
+      return dup_if_possible(params) unless params.is_a?(PARAM_TYPE)
+      {}.tap do |dup|
+        params.each do |key, value|
+          dup[key] = deep_dup_to_hash(value)
+        end
+      end
+    end
+
+    def dup_if_possible(v)
+      v.duplicable? ? v.dup : v
+    end
+  end
+end

data/lib/shields_up/shields_up.rb

@@ -0,0 +1,10 @@
+module ShieldsUp
+  def self.included(klass)
+    klass.before_filter do
+      self.params = ShieldsUp::Parameters.new(params, self) unless params.is_a?(ShieldsUp::Parameters)
+    end
+    klass.rescue_from(ShieldsUp::ParameterMissing) do |parameter_missing_exception|
+      render :text => "Required parameter missing: #{parameter_missing_exception}", :status => :bad_request
+    end
+  end
+end

data/lib/shields_up/version.rb

@@ -0,0 +1,3 @@
+module ShieldsUp
+  VERSION = '0.17.0'.freeze
+end

data/lib/shields_up.rb

@@ -0,0 +1,3 @@
+require 'shields_up/shields_up'
+require 'shields_up/exceptions'
+require 'shields_up/parameters'

data/shields_up.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shields_up/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'shields_up'
+  s.version       = ShieldsUp::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ['AppFolio']
+  s.email         = 'dev@appfolio.com'
+  s.description   = 'Mass assignment Protection made by AppFolio Inc., inspired by strong_parameters.'
+  s.summary       = s.description
+  s.homepage      = 'http://github.com/appfolio/shields_up'
+  s.licenses      = ['MIT']
+
+  s.files         = Dir['**/*'].reject{ |f| f[%r{^pkg/}] || f[%r{^test/}] }
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.add_dependency('activesupport', '~> 3.2')
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: shields_up
+version: !ruby/object:Gem::Version
+  version: 0.17.0
+platform: ruby
+authors:
+- AppFolio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Mass assignment Protection made by AppFolio Inc., inspired by strong_parameters.
+email: dev@appfolio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/shields_up.rb
+- lib/shields_up/exceptions.rb
+- lib/shields_up/parameters.rb
+- lib/shields_up/shields_up.rb
+- lib/shields_up/version.rb
+- shields_up.gemspec
+homepage: http://github.com/appfolio/shields_up
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Mass assignment Protection made by AppFolio Inc., inspired by strong_parameters.
+test_files: []