action_controller_tweaks 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9549506d76d4ea2032b34467b985b9ae3bc173d2
-  data.tar.gz: cf82467af5dc365d2a9638cdc2ee282854a69640
+  metadata.gz: d18d5ac685043630bc71743acdbdfa01954ca26d
+  data.tar.gz: decb6e92a43ee69c13b753d1fe7ba350011aea9b
 SHA512:
-  metadata.gz: ceba069ed9da41fd92bf3ab52c1e578929ef38fc059b041d6bd4ee6fd1fee0ac7a1e5fd8db718a2303e6a8335314dca388c2b654d7ecea6a7bd73264c0fbbd1d
-  data.tar.gz: b10c3a0d6a0feb7cf2c30e48ab479856d7dc8052617d5c2959486cfc5119b8aedd4eb08d25250671f91119ab961debe2bf322e50675a5fbe55fcfb93ea47452f
+  metadata.gz: 218dc267dee725e8084a96c09ed05403ea2b6591a9b3ad438349f3584fe5499a635e6d46c204cd5f1731d3e01015bfc95fd639b41c04ce856b7d28acac7e404e
+  data.tar.gz: ffae98b515dd4d3ac1068c87e484e5b32b9cd47e8abbccfb5a780bf28e108879849c37a842ce654592d5ee52416b0fa33a7ec1b8a3140a1fbc6e3fdc87f02c1e

data/.travis.yml

@@ -1,11 +1,12 @@
-before_install:
-- gem install bundler -v=1.5.2
-- bundle --version
+language: ruby
+cache:
+- bundler
 rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.1.1
 gemfile:
   - gemfiles/rails3_2.gemfile
   - gemfiles/rails4_0.gemfile

data/Appraisals

@@ -1,12 +1,14 @@
 
 appraise "rails3-2" do
-  version = "3.2.16"
+  version = "3.2.17"
   gem 'activesupport', version
   gem 'actionpack', version
+  gem 'activerecord', version
 end
 
 appraise "rails4-0" do
-  version = "4.0.2"
+  version = "4.0.3"
   gem 'activesupport', version
   gem 'actionpack', version
+  gem 'activerecord', version
 end

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 ### Changelog
 
 
+- **0.3.0**
+  - Add method `#set_session_with_expiry`
+  - Add option `expires_in` and `expires_at` to #set_session
+  - Fix invalid header when using `#set_no_cache` for HTTP 1.0
+  - Raise error when reserved session key(s) is set through the provided method
+
 - **0.2.0**
   - Add option `expire_at` to #set_session
   - Use semantic versioning

data/README.md

@@ -9,11 +9,11 @@ Tested against:
 - Action Controller of version `3.2` and `4.0` (`3.1` and below got problem with buggy `rspec-rails`)
 - Ruby `1.9.2`, `1.9.3`, `2.0.0` (except Rails 4 with `1.9.2`)
 
-[![Build Status](https://travis-ci.org/PikachuEXE/action_controller_tweaks.png?branch=master)](https://travis-ci.org/PikachuEXE/action_controller_tweaks)
-[![Gem Version](https://badge.fury.io/rb/action_controller_tweaks.png)](http://badge.fury.io/rb/action_controller_tweaks)
-[![Dependency Status](https://gemnasium.com/PikachuEXE/action_controller_tweaks.png)](https://gemnasium.com/PikachuEXE/action_controller_tweaks)
-[![Coverage Status](https://coveralls.io/repos/PikachuEXE/action_controller_tweaks/badge.png)](https://coveralls.io/r/PikachuEXE/action_controller_tweaks)
-[![Code Climate](https://codeclimate.com/github/PikachuEXE/action_controller_tweaks.png)](https://codeclimate.com/github/PikachuEXE/action_controller_tweaks)
+[![Build Status](http://img.shields.io/travis/PikachuEXE/action_controller_tweaks.svg)](https://travis-ci.org/PikachuEXE/action_controller_tweaks)
+[![Gem Version](http://img.shields.io/gem/v/action_controller_tweaks.svg)](http://badge.fury.io/rb/action_controller_tweaks)
+[![Dependency Status](http://img.shields.io/gemnasium/PikachuEXE/action_controller_tweaks.svg)](https://gemnasium.com/PikachuEXE/action_controller_tweaks)
+[![Coverage Status](http://img.shields.io/coveralls/PikachuEXE/action_controller_tweaks.svg)](https://coveralls.io/r/PikachuEXE/action_controller_tweaks)
+[![Code Climate](http://img.shields.io/codeclimate/github/PikachuEXE/action_controller_tweaks.svg)](https://codeclimate.com/github/PikachuEXE/action_controller_tweaks)
 
 Install
 =======
@@ -41,11 +41,24 @@ Usage:
   set_no_cache
 ```
 
-### `#set_session`
+### `#set_session` & `#set_session_with_expiry`
 I write this on my own, it's ok to blame me if it's buggy :P  
 This method let's you set session, with expiry time!  
+It depends on `before_filter`/`before_action` to remove expired session keys  
+Valid options: `expire_in`, `expires_in`, `expire_at`, `expires_at`
 Example:
 ```ruby
+# Option keys are NOT checked
+set_session(:key, 'value') # => Just like session[:key] = 'value'
+
 set_session(:key, 'value', expire_in: 1.day)
+set_session(:key, 'value', expires_in: 1.day)
+
+set_session(:key, 'value', expire_at: 1.day.from_now)
+set_session(:key, 'value', expires_at: 1.day.from_now)
+
+# Option keys are checked
+# You must pass valid options or error will be raised
+set_session_with_expiry(:key, 'value', expires_in: 1.day)
 ```
 Note: Please don't use the session key `session_keys_to_expire`, it's reserved for internal processing

data/action_controller_tweaks.gemspec

@@ -9,7 +9,7 @@ require "#{gem_name}/version"
 Gem::Specification.new do |s|
   s.platform      = Gem::Platform::RUBY
   s.name          = gem_name
-  s.version       = ActionControllerTweaks::VERSION
+  s.version       = ActionControllerTweaks.version
   s.summary       = "Some Tweaks for ActionController"
   s.description   = "ActionController is great, but could be better. Here are some tweaks for it."
 

data/gemfiles/rails3_2.gemfile

@@ -2,7 +2,8 @@
 
 source "https://rubygems.org"
 
-gem "activesupport", "3.2.16"
-gem "actionpack", "3.2.16"
+gem "activesupport", "3.2.17"
+gem "actionpack", "3.2.17"
+gem "activerecord", "3.2.17"
 
 gemspec :path=>"../"

data/gemfiles/rails4_0.gemfile

@@ -2,7 +2,8 @@
 
 source "https://rubygems.org"
 
-gem "activesupport", "4.0.2"
-gem "actionpack", "4.0.2"
+gem "activesupport", "4.0.3"
+gem "actionpack", "4.0.3"
+gem "activerecord", "4.0.3"
 
 gemspec :path=>"../"

data/lib/action_controller_tweaks/caching.rb

@@ -6,8 +6,8 @@ module ActionControllerTweaks
 
     HEADERS = {
       "Cache-Control" => "no-cache, no-store, max-age=0, must-revalidate, pre-check=0, post-check=0", # HTTP 1.1
-      "no-cache" => "no-cache", # HTTP 1.0
-      "Expires" => "Fri, 01 Jan 1990 00:00:00 GMT", # Proxies
+      "Pragma" => "no-cache", # HTTP 1.0
+      "Expires" => "Fri, 01 Jan 1990 00:00:00 GMT", # HTTP 1.0
     }.freeze
 
     included do

data/lib/action_controller_tweaks/session.rb

@@ -5,7 +5,18 @@ module ActionControllerTweaks
   module Session
     extend ActiveSupport::Concern
 
-    SPECIAL_KEYS = %w( session_keys_to_expire )
+    module Errors
+      InvalidOptionKeys = Class.new(ArgumentError)
+      ReservedSessionKeyConflict = Class.new(ArgumentError)
+    end
+
+    RESERVED_SESSION_KEYS = %w( session_keys_to_expire )
+    VALID_OPTION_KEYS = [
+      :expires_in,
+      :expires_at,
+      :expire_in,
+      :expire_at,
+    ].freeze
 
     class InvalidOptionValue < ArgumentError
       def self.new(option_key, options_value, expected_types)
@@ -19,13 +30,17 @@ module ActionControllerTweaks
 
       private
 
+      # Set session just like `session[key] = value` but accept some options about expiry
+      #
+      # @option expires_in [Integer] How long from now should the session value be expired
+      # @option expire_in [Integer] same as `expires_in`
+      # @option expires_at [Integer] What time should the session value be expired (using a time in the past would expire at next request)
+      # @option expire_at [Integer] same as `expires_at`
       def set_session(key, value, options = {})
         options.symbolize_keys!
 
-        key = key.to_sym
-
-        if SPECIAL_KEYS.include?(key.to_s)
-          return
+        if RESERVED_SESSION_KEYS.include?(key.to_s)
+          raise Errors::ReservedSessionKeyConflict.new, "you are trying to set #{value} to #{key}, but reserved by ActionControllerTweaks::Session"
         end
 
         session[key] = value
@@ -33,24 +48,39 @@ module ActionControllerTweaks
         # Set special session
         new_session_keys_to_expire = session_keys_to_expire
 
-        expire_in, expire_at = options.delete(:expire_in), options.delete(:expire_at)
+        expires_in = options.delete(:expires_in) || options.delete(:expire_in)
+        expires_at = options.delete(:expires_at) || options.delete(:expire_at)
 
-        if expire_at && expire_at.respond_to?(:to_time)
-          expire_at = expire_at.to_time
+        if expires_at && expires_at.respond_to?(:to_time)
+          expires_at = expires_at.to_time
         end
 
-        raise InvalidOptionValue.new(:expire_in, expire_in, Numeric) if expire_in && !expire_in.is_a?(Numeric)
-        raise InvalidOptionValue.new(:expire_at, expire_at, Time) if expire_at && !expire_at.is_a?(Time)
+        raise InvalidOptionValue.new(:expires_in, expires_in, Numeric) if expires_in && !expires_in.is_a?(Numeric)
+        raise InvalidOptionValue.new(:expires_at, expires_at, Time) if expires_at && !expires_at.is_a?(Time)
 
-        new_session_keys_to_expire[key] = if expire_in
-          expire_in.from_now
-        elsif expire_at
-          expire_at
+        new_session_keys_to_expire[key] = if expires_in
+          expires_in.from_now
+        elsif expires_at
+          expires_at
         end
 
         session[:session_keys_to_expire] = new_session_keys_to_expire
       end
 
+      # set value in session just like `set_session`, but checked option keys
+      #
+      # @raise [ActionControllerTweaks::Session::Errors::InvalidOptionKeys]
+      def set_session_with_expiry(key, value, options = {})
+        option_keys = options.symbolize_keys.keys
+        required_option_key_present = option_keys.any? do |key|
+          VALID_OPTION_KEYS.include?(key)
+        end
+        invalid_option_key_absent = (option_keys - VALID_OPTION_KEYS.dup).empty?
+        (required_option_key_present && invalid_option_key_absent) or raise ActionControllerTweaks::Session::Errors::InvalidOptionKeys
+
+        set_session(key, value, options = {})
+      end
+
       def delete_expired_session_keys
         # Remove keys that are expired
         session_keys_to_expire.each do |key, expire_at_str|

data/lib/action_controller_tweaks/version.rb

@@ -1,3 +1,7 @@
 module ActionControllerTweaks
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
+
+  def self.version
+    Gem::Version.new(VERSION)
+  end
 end

data/spec/action_controller_tweaks_spec.rb

@@ -20,154 +20,294 @@ describe PostsController, type: :controller do
   end
 
   describe '::Session' do
+    let(:session_key) { :key }
+    let(:session_value) { 'value' }
+
     describe '#set_session' do
-      let(:session_key) { :key }
-      let(:session_value) { 'value' }
       let(:expire_in) { 60 * 60 } # 1 hour
       let(:expire_at) { Time.new(2014, 1, 1).in_time_zone }
       let(:time_now) { Time.new(2013, 1, 1).in_time_zone }
+      # Corrected option keys
+      let(:expires_in) { expire_in }
+      let(:expires_at) { expire_at }
 
       context 'when calling it without option' do
-        before do
+        let :set_session do
           controller.send(:set_session, session_key, session_value)
         end
 
-        it 'set the session' do
-          session[session_key].should eq session_value
+        context 'with normal key' do
+          before do
+            set_session
+          end
+
+          it 'set the session' do
+            session[session_key].should eq session_value
+          end
         end
 
-        context 'with a special key' do
-          let(:session_key) { ActionControllerTweaks::Session::SPECIAL_KEYS.first }
+        context 'with a reserved key' do
+          let(:session_key) { ActionControllerTweaks::Session::RESERVED_SESSION_KEYS.first }
 
-          it 'does not set the session' do
-            session[session_key].should be_nil
+          it 'raise error' do
+            expect { set_session }.to raise_error(ActionControllerTweaks::Session::Errors::ReservedSessionKeyConflict)
           end
         end
       end
 
-      context 'when calling it with option expire_in' do
-        let!(:time_before_expire) { time_now + (expire_in / 2) }
-        let!(:time_after_expire) { time_now + (expire_in * 2) }
+      context 'for old option keys' do
+        context 'when calling it with option expire_in' do
+          let!(:time_before_expire) { time_now + (expire_in / 2) }
+          let!(:time_after_expire) { time_now + (expire_in * 2) }
 
-        before do
-          Timecop.freeze(time_now)
-          controller.send(:set_session, session_key, session_value, expire_in: expire_in)
-        end
+          before do
+            Timecop.freeze(time_now)
+            controller.send(:set_session, session_key, session_value, expire_in: expire_in)
+          end
 
-        after do
-          Timecop.return
-        end
+          after do
+            Timecop.return
+          end
+
+          it 'set the session' do
+            session[session_key].should eq session_value
+          end
 
-        it 'set the session' do
-          session[session_key].should eq session_value
+          context 'before expire time' do
+            before do
+              Timecop.travel(time_before_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session[session_key].should eq session_value
+            end
+          end
+          context 'after expire time' do
+            before do
+              Timecop.travel(time_after_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session.key?(session_key).should be_false
+            end
+          end
         end
 
-        context 'before expire time' do
+        context 'when calling it with option expire_at' do
+          let!(:time_before_expire) { expire_at - 1 }
+          let!(:time_after_expire) { expire_at + 1 }
+
           before do
-            Timecop.travel(time_before_expire)
-            # Runs before_filter
-            get :index
+            Timecop.freeze(time_now)
+            controller.send(:set_session, session_key, session_value, expire_at: expire_at)
+          end
+
+          after do
+            Timecop.return
           end
 
-          it 'keeps the session key' do
+          it 'set the session' do
             session[session_key].should eq session_value
           end
+
+          context 'before expire time' do
+            before do
+              Timecop.travel(time_before_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session[session_key].should eq session_value
+            end
+          end
+          context 'after expire time' do
+            before do
+              Timecop.travel(time_after_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session.key?(session_key).should be_false
+            end
+          end
         end
-        context 'after expire time' do
+      end
+      context 'for new option keys' do
+        context 'when calling it with option expires_in' do
+          let!(:time_before_expire) { time_now + (expires_in / 2) }
+          let!(:time_after_expire) { time_now + (expires_in * 2) }
+
           before do
-            Timecop.travel(time_after_expire)
-            # Runs before_filter
-            get :index
+            Timecop.freeze(time_now)
+            controller.send(:set_session, session_key, session_value, expires_in: expires_in)
           end
 
-          it 'keeps the session key' do
-            session.key?(session_key).should be_false
+          after do
+            Timecop.return
           end
-        end
-      end
 
-      context 'when calling it with option expire_at' do
-        let!(:time_before_expire) { expire_at - 1 }
-        let!(:time_after_expire) { expire_at + 1 }
+          it 'set the session' do
+            session[session_key].should eq session_value
+          end
 
-        before do
-          Timecop.freeze(time_now)
-          controller.send(:set_session, session_key, session_value, expire_at: expire_at)
-        end
+          context 'before expire time' do
+            before do
+              Timecop.travel(time_before_expire)
+              # Runs before_filter
+              get :index
+            end
 
-        after do
-          Timecop.return
+            it 'keeps the session key' do
+              session[session_key].should eq session_value
+            end
+          end
+          context 'after expire time' do
+            before do
+              Timecop.travel(time_after_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session.key?(session_key).should be_false
+            end
+          end
         end
 
-        it 'set the session' do
-          session[session_key].should eq session_value
-        end
+        context 'when calling it with option expires_at' do
+          let!(:time_before_expire) { expires_at - 1 }
+          let!(:time_after_expire) { expires_at + 1 }
 
-        context 'before expire time' do
           before do
-            Timecop.travel(time_before_expire)
-            # Runs before_filter
-            get :index
+            Timecop.freeze(time_now)
+            controller.send(:set_session, session_key, session_value, expire_at: expires_at)
           end
 
-          it 'keeps the session key' do
-            session[session_key].should eq session_value
+          after do
+            Timecop.return
           end
-        end
-        context 'after expire time' do
-          before do
-            Timecop.travel(time_after_expire)
-            # Runs before_filter
-            get :index
+
+          it 'set the session' do
+            session[session_key].should eq session_value
           end
 
-          it 'keeps the session key' do
-            session.key?(session_key).should be_false
+          context 'before expire time' do
+            before do
+              Timecop.travel(time_before_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session[session_key].should eq session_value
+            end
+          end
+          context 'after expire time' do
+            before do
+              Timecop.travel(time_after_expire)
+              # Runs before_filter
+              get :index
+            end
+
+            it 'keeps the session key' do
+              session.key?(session_key).should be_false
+            end
           end
         end
       end
 
+
       context 'when option value with different types is passed into options' do
         let(:method_call) do
           controller.send(:set_session, session_key, session_value, options)
         end
-        context 'for expire_in' do
-          let(:options) { {expire_in: expire_in.to_s} }
 
-          specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
-        end
-        context 'for expire_at' do
-          context 'with a Hash' do
-            # String#to_time would be nil if format invalid
-            let(:options) { {expire_at: {}} }
+        context 'for old option keys' do
+          context 'for expire_in' do
+            let(:options) { {expire_in: expire_in.to_s} }
 
             specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
           end
-          context 'with a blank String' do
-            # String#to_time would be nil if format invalid
-            let(:options) { {expire_at: ''} }
-
-            specify { expect{ method_call }.to_not raise_error }
-          end
-          context 'with a time String' do
-            let(:options) { {expire_at: expire_at.to_s} }
-
-            specify { expect{ method_call }.to_not raise_error }
-          end
-          context 'with a Time' do
-            let(:options) { {expire_at: expire_at.to_time} }
-
-            specify { expect{ method_call }.to_not raise_error }
+          context 'for expire_at' do
+            context 'with a Hash' do
+              # String#to_time would be nil if format invalid
+              let(:options) { {expire_at: {}} }
+
+              specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
+            end
+            context 'with a blank String' do
+              # String#to_time would be nil if format invalid
+              let(:options) { {expire_at: ''} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a time String' do
+              let(:options) { {expire_at: expire_at.to_s} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a Time' do
+              let(:options) { {expire_at: expire_at.to_time} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a Date' do
+              let(:options) { {expire_at: expire_at.to_date} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a DateTime' do
+              let(:options) { {expire_at: expire_at.in_time_zone} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
           end
-          context 'with a Date' do
-            let(:options) { {expire_at: expire_at.to_date} }
+        end
+        context 'for new option keys' do
+          context 'for expires_in' do
+            let(:options) { {expires_in: expires_in.to_s} }
 
-            specify { expect{ method_call }.to_not raise_error }
+            specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
           end
-          context 'with a DateTime' do
-            let(:options) { {expire_at: expire_at.in_time_zone} }
-
-            specify { expect{ method_call }.to_not raise_error }
+          context 'for expires_at' do
+            context 'with a Hash' do
+              # String#to_time would be nil if format invalid
+              let(:options) { {expires_at: {}} }
+
+              specify { expect{ method_call }.to raise_error(ActionControllerTweaks::Session::InvalidOptionValue) }
+            end
+            context 'with a blank String' do
+              # String#to_time would be nil if format invalid
+              let(:options) { {expires_at: ''} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a time String' do
+              let(:options) { {expires_at: expire_at.to_s} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a Time' do
+              let(:options) { {expires_at: expire_at.to_time} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a Date' do
+              let(:options) { {expires_at: expire_at.to_date} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
+            context 'with a DateTime' do
+              let(:options) { {expires_at: expire_at.in_time_zone} }
+
+              specify { expect{ method_call }.to_not raise_error }
+            end
           end
         end
       end
@@ -201,5 +341,44 @@ describe PostsController, type: :controller do
         end
       end
     end
+
+    describe '#set_session_with_expiry' do
+      let(:method_call) do
+        controller.send(:set_session_with_expiry, session_key, session_value, options)
+      end
+
+      context 'when call with no options' do
+        let!(:options) { {} }
+
+        specify { expect{method_call}.to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys) }
+      end
+      context 'when call with invalid option keys' do
+        let!(:options) { {key: :value} }
+
+        specify { expect{method_call}.to raise_error(ActionControllerTweaks::Session::Errors::InvalidOptionKeys) }
+      end
+      context 'when call with valid option keys' do
+        context 'like expire_in' do
+          let!(:options) { {expire_in: 1.day} }
+
+          specify { expect{method_call}.to_not raise_error }
+        end
+        context 'like expire_at' do
+          let!(:options) { {expire_at: 1.day.from_now} }
+
+          specify { expect{method_call}.to_not raise_error }
+        end
+        context 'like expires_in' do
+          let!(:options) { {expires_in: 1.day} }
+
+          specify { expect{method_call}.to_not raise_error }
+        end
+        context 'like expires_at' do
+          let!(:options) { {expires_at: 1.day.from_now} }
+
+          specify { expect{method_call}.to_not raise_error }
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_controller_tweaks
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - PikachuEXE
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-17 00:00:00.000000000 Z
+date: 2014-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -244,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.4.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Some Tweaks for ActionController