switch_user 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06adf7119a277108834d59b13db51a1db026d52b
-  data.tar.gz: 993205a4f732d652bf60d4f083d2d9f0ed54b73a
+  metadata.gz: 4cc1c6867f857a993d2f742e22150537d5ef29aa
+  data.tar.gz: 9c4e70bd6dd34f625000e5862855fffdcb08fe27
 SHA512:
-  metadata.gz: a190126c3a2323ff087712933e3ace25110c624435897c6df8c803959fbd288ac19130c32c90fff7215e38708730de2fa4d8568aced23d756da1b36bdfe975d5
-  data.tar.gz: 91ab7a7bba1f5535f913e230d8f42a47a9eb84b2575843e91d95ff372631dd3d5cbb1d2e05c91538faa79644f7ac22dc14e810fcc6179adfdc725f1446a77f8f
+  metadata.gz: c7f26cd2dff27bd70b98f84bbe7e6ab9e9fcecb68903d353b7faa3e853789cc6278773210657f281a8223d8aa6bc0f6a5041490df9a61daa6b2d6112a06c24e7
+  data.tar.gz: '08c2e33483cfbac4555843d32f408f4ff8d60c45e26e82e4d1bd65c21d6f4a9cf1a5d992a4a3c440a867bc5d05924232600a14971b5ff0522c9af828f16bf625'

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Next Release
 
+## 1.5.0 (10/27/2017)
+
+* Allow `SwitchUser.switch_back` to be considered even when not calling `#remember_user`.
+* Use `redirect_back` for rails 5
+
 ## 1.4.0 (10/21/2016)
 
 * Add ability to `store_sign_in` info with devise provider

data/README.md

@@ -14,7 +14,7 @@ switch_user is very useful in such use cases
 
 ## Example
 
-Visit here: <http://switch-user-example.heroku.com>, switch the current user in the select box.
+Visit here: <http://switch-user-example.heroku.com/admin>, switch the current user in the select box.
 
 And source code here: <https://github.com/flyerhzm/switch_user_example>
 
@@ -24,6 +24,9 @@ Add in Gemfile.
 ```ruby
 gem "switch_user"
 ```
+
+If you get the following error: **undefined method `before_action' for SwitchUserController:Class**, you are probably using an older version of Rails (<4). You can use this gem: https://github.com/pschambacher/rails3-before_action
+
 ## Usage
 
 Add following code into your layout page.
@@ -69,7 +72,7 @@ SwitchUser.setup do |config|
   # available_users is a hash,
   # key is the model name of user (:user, :admin, or any name you use),
   # value is a block that return the users that can be switched.
-  config.available_users = { :user => lambda { User.all } } # use User.scoped instead for rails 3.2
+  config.available_users = { user: -> { User.all } } # use User.scoped instead for rails 3.2
 
   # available_users_identifiers is a hash,
   # keys in this hash should match a key in the available_users hash
@@ -77,55 +80,55 @@ SwitchUser.setup do |config|
   # defaults to id
   # this hash is to allow you to specify a different column to
   # expose for instance a username on a User model instead of id
-  config.available_users_identifiers = { :user => :id }
+  config.available_users_identifiers = { user: :id }
 
   # available_users_names is a hash,
   # keys in this hash should match a key in the available_users hash
   # value is the column name which will be displayed in select box
-  config.available_users_names = { :user => :email }
+  config.available_users_names = { user: :email }
 
   # controller_guard is a block,
   # if it returns true, the request will continue,
   # else the request will be refused and returns "Permission Denied"
   # if you switch from "admin" to user, the current_user param is "admin"
-  config.controller_guard = lambda { |current_user, request| Rails.env.development? }
+  config.controller_guard = ->(current_user, request) { Rails.env.development? }
 
   # view_guard is a block,
   # if it returns true, the switch user select box will be shown,
   # else the select box will not be shown
   # if you switch from admin to "user", the current_user param is "user"
-  config.view_guard = lambda { |current_user, request| Rails.env.development? }
+  config.view_guard = ->(current_user, request)  { Rails.env.development? }
 
   # redirect_path is a block, it returns which page will be redirected
   # after switching a user.
-  config.redirect_path = lambda { |request, params| '/' }
+  config.redirect_path = ->(request, params) { '/' }
 end
 ```
 If you need to override the default configuration, run <code>rails g switch_user:install</code> and a copy of the configuration file will be copied to <code>config/initializers/switch_user.rb</code> in your project.
 
 If you want to switch both available users and available admins
 ```ruby
-config.available_users = { :user => lambda { User.available }, :admin => lambda { Admin.available } }
+config.available_users = { :user => -> { User.available }, :admin => -> { Admin.available } }
 ```
 If you want to use name column as the user identifier
 ```ruby
-config.available_users_identifiers => { :user => :name }
+config.available_users_identifiers => { user: :name }
 ```
 If you want to display the login field in switch user select box
 ```ruby
-config.available_users_names = { :user => :login }
+config.available_users_names = { user: :login }
 ```
 If you only allow switching from admin to user in production environment
 ```ruby
-config.controller_guard = lambda { |current_user, request| Rails.env == "production" and current_user.admin? }
+config.controller_guard = ->(current_user, request) { Rails.env.production? && current_user.admin? }
 ```
 If you only want to display switch user select box for admins in production environment
 ```ruby
-config.view_guard = lambda { |current_user, request| Rails.env == "production" and current_user and current_user.admin? }
+config.view_guard = ->(current_user, request) { Rails.env.production? && current_user && current_user.admin? }
 ```
 If you want to redirect user to "/dashboard" page
 ```ruby
-config.redirect_path = lambda { |request, params| "/dashboard" }
+config.redirect_path = ->(request, params) { "/dashboard" }
 ```
 If you want to hide a 'Guest' item in the helper dropdown list
 ```ruby
@@ -137,16 +140,14 @@ Sometimes you'll want to be able to switch to an unprivileged user and then back
 You will need to make the following modifications to your configuration:
 ```ruby
 config.switch_back = true
-config.controller_guard = lambda { |current_user, request, original_user|
-  current_user && current_user.admin? || original_user && original_user.super_admin?
-}
+config.controller_guard = ->(current_user, request, original_user) { current_user && current_user.admin? || original_user && original_user.super_admin? }
 # Do something similar for the view_guard as well.
 ```
 This example would allow an admin user to user switch_user, but would only let you switch back to another user if the original user was a super admin.
 
 ## Using SwitchUser with RSpec and Capybara
 
-Add the following code to spec/support/switch_user.rb or spec/spec_helper.rb :
+Add the following code to spec/support/switch_user.rb or spec/spec_helper.rb:
 
 ```ruby
 require 'switch_user/rspec'
@@ -157,7 +158,7 @@ You can now write your specs like so :
 ```ruby
 feature "Your feature", type: :feature do
   background do
-    @user = User.make(:email => 'user@example.com', :password => 'password')
+    @user = User.make(email: 'user@example.com', password: 'password')
   end
 
   scenario "Your scenario" do
@@ -189,6 +190,6 @@ This feature should be used with extreme caution because of the security implica
 
 ## Credit
 
-Copyright © 2010 - 2015 Richard Huang (flyerhzm@gmail.com), released under the MIT license
+Copyright © 2010 - 2017 Richard Huang (flyerhzm@gmail.com), released under the MIT license
 
 [0]: https://github.com/tablatom/hobo

data/app/controllers/switch_user_controller.rb

@@ -1,23 +1,35 @@
 class SwitchUserController < ApplicationController
-  before_action :developer_modes_only
+  before_action :developer_modes_only, :switch_back
 
   def set_current_user
     handle_request(params)
 
-    redirect_to(SwitchUser.redirect_path.call(request, params))
+    redirect_path = SwitchUser.redirect_path.call(request, params)
+    if Rails.version.to_i >= 5 && redirect_path == :back
+      redirect_back(fallback_location: root_path)
+    else
+      redirect_to(redirect_path)
+    end
   end
 
   def remember_user
-    # NOOP unless the user has explicity enabled this feature
-    if SwitchUser.switch_back
-      provider.remember_current_user(params[:remember] == "true")
+    redirect_path = SwitchUser.redirect_path.call(request, params)
+    if Rails.version.to_i >= 5 && redirect_path == :back
+      redirect_back(fallback_location: root_path)
+    else
+      redirect_to(redirect_path)
     end
-
-    redirect_to(SwitchUser.redirect_path.call(request, params))
   end
 
   private
 
+  def switch_back
+    if SwitchUser.switch_back
+      provider.remember_current_user(true) if params[:remember] == "true"
+      provider.remember_current_user(false) if params[:remember] == "false"
+    end
+  end
+
   def developer_modes_only
     raise ActionController::RoutingError.new('Do not try to hack us.') unless available?
   end
@@ -36,9 +48,9 @@ class SwitchUserController < ApplicationController
         return
       end
       if SwitchUser.login_exclusive
-        provider.login_exclusive(record.user, :scope => record.scope)
+        provider.login_exclusive(record.user, scope: record.scope)
       else
-        provider.login_inclusive(record.user, :scope => record.scope)
+        provider.login_inclusive(record.user, scope: record.scope)
       end
     end
   end

data/app/helpers/switch_user_helper.rb

@@ -23,11 +23,11 @@ module SwitchUserHelper
 
     option_tags = grouped_options_for_select(grouped_options_container.to_a, selected_user)
 
-    render :partial => "switch_user/widget",
-           :locals => {
-             :option_tags => option_tags,
-             :classes => options[:class],
-             :styles => options[:style],
+    render partial: "switch_user/widget",
+           locals: {
+             option_tags: option_tags,
+             classes: options[:class],
+             styles: options[:style],
            }
   end
 

data/app/views/switch_user/_widget.html.erb

@@ -1,4 +1,4 @@
 <% if SwitchUser.switch_back %>
-  <%= check_box_tag "remember_user", "remember_user", provider.original_user.present?, :onchange => "location.href = '#{ActionController::Base.relative_url_root || '/'}switch_user/remember_user?remember=' + encodeURIComponent(this.checked)" %>
+  <%= check_box_tag "remember_user", "remember_user", provider.original_user.present?, onchange: "location.href = '#{ActionController::Base.relative_url_root || '/'}switch_user/remember_user?remember=' + encodeURIComponent(this.checked)" %>
 <% end %>
-<%= select_tag "switch_user_identifier", option_tags, :onchange => "location.href = '#{ActionController::Base.relative_url_root || '/'}switch_user?scope_identifier=' + encodeURIComponent(this.options[this.selectedIndex].value)", :class => classes, :style => styles %>
+<%= select_tag "switch_user_identifier", option_tags, onchange: "location.href = '#{ActionController::Base.relative_url_root || '/'}switch_user?scope_identifier=' + encodeURIComponent(this.options[this.selectedIndex].value)", class: classes, style: styles %>

data/config/routes.rb

@@ -1,4 +1,4 @@
 Rails.application.routes.draw do
-  get :switch_user, :to => 'switch_user#set_current_user'
-  get 'switch_user/remember_user', :to => 'switch_user#remember_user'
+  get :switch_user, to: 'switch_user#set_current_user'
+  get 'switch_user/remember_user', to: 'switch_user#remember_user'
 end

data/lib/generators/switch_user/install/templates/switch_user.rb

@@ -5,7 +5,7 @@ SwitchUser.setup do |config|
   # available_users is a hash,
   # key is the model name of user (:user, :admin, or any name you use),
   # value is a block that return the users that can be switched.
-  config.available_users = { :user => lambda { User.all } }
+  config.available_users = { user: -> { User.all } }
 
   # available_users_identifiers is a hash,
   # keys in this hash should match a key in the available_users hash
@@ -13,28 +13,28 @@ SwitchUser.setup do |config|
   # defaults to id
   # this hash is to allow you to specify a different column to
   # expose for instance a username on a User model instead of id
-  config.available_users_identifiers = { :user => :id }
+  config.available_users_identifiers = { user: :id }
 
   # available_users_names is a hash,
   # keys in this hash should match a key in the available_users hash
   # value is the column name which will be displayed in select box
-  config.available_users_names = { :user => :email }
+  config.available_users_names = { user: :email }
 
   # controller_guard is a block,
   # if it returns true, the request will continue,
   # else the request will be refused and returns "Permission Denied"
   # if you switch from "admin" to user, the current_user param is "admin"
-  config.controller_guard = lambda { |current_user, request| Rails.env.development? }
+  config.controller_guard = ->(current_user, request) { Rails.env.development? }
 
   # view_guard is a block,
   # if it returns true, the switch user select box will be shown,
   # else the select box will not be shown
   # if you switch from admin to "user", the current_user param is "user"
-  config.view_guard = lambda { |current_user, request| Rails.env.development? }
+  config.view_guard = ->(current_user, request) { Rails.env.development? }
 
   # redirect_path is a block, it returns which page will be redirected
   # after switching a user.
-  config.redirect_path = lambda { |request, params| '/' }
+  config.redirect_path = ->(request, params) { '/' }
 
   # helper_with_guest is a boolean value, if it set to false
   # the guest item in the helper won't be shown

data/lib/switch_user.rb

@@ -53,13 +53,13 @@ module SwitchUser
 
   def self.reset_config
     self.provider = :devise
-    self.available_users = { :user => lambda { User.all } }
-    self.available_users_identifiers = { :user => :id }
-    self.available_users_names = { :user => :email }
+    self.available_users = { user: -> { User.all } }
+    self.available_users_identifiers = { user: :id }
+    self.available_users_names = { user: :email }
     self.guard_class = "SwitchUser::LambdaGuard"
-    self.controller_guard = lambda { |current_user, request| Rails.env.development? }
-    self.view_guard = lambda { |current_user, request| Rails.env.development? }
-    self.redirect_path = lambda { |request, params| request.env["HTTP_REFERER"] ? :back : root_path }
+    self.controller_guard = ->(current_user, request) { Rails.env.development? }
+    self.view_guard = ->(current_user, request) { Rails.env.development? }
+    self.redirect_path = ->(request, params) { request.env["HTTP_REFERER"] ? :back : root_path }
     self.session_key = :user_id
     self.helper_with_guest = true
     self.switch_back = false

data/lib/switch_user/data_source.rb

@@ -11,7 +11,7 @@ module SwitchUser
     end
 
     def find_scope_id(scope_id)
-      sources.map {|source| source.find_scope_id(scope_id) }.compact.first
+      sources.map { |source| source.find_scope_id(scope_id) }.compact.first
     end
   end
 
@@ -40,7 +40,7 @@ module SwitchUser
 
   class GuestDataSource
     def all
-      [ GuestRecord.new ]
+      [GuestRecord.new]
     end
 
     def find_scope_id(scope_id)

data/lib/switch_user/provider/base.rb

@@ -33,7 +33,7 @@ module SwitchUser
         user_identifier = @controller.session[:original_user_scope_identifier]
 
         if user_identifier
-          UserLoader.prepare(:scope_identifier => user_identifier).user
+          UserLoader.prepare(scope_identifier: user_identifier).user
         end
       end
 

data/lib/switch_user/provider/devise.rb

@@ -6,7 +6,7 @@ module SwitchUser
         @warden = @controller.warden
       end
 
-      def login(user, scope = :user)
+      def login(user, scope = nil)
         if SwitchUser.provider.is_a?(Hash) && SwitchUser.provider[:store_sign_in]
           @warden.set_user(user, scope: scope)
         else
@@ -14,11 +14,11 @@ module SwitchUser
         end
       end
 
-      def logout(scope = :user)
+      def logout(scope = nil)
         @warden.logout(scope)
       end
 
-      def current_user(scope = :user)
+      def current_user(scope = nil)
         @warden.user(scope)
       end
     end

data/lib/switch_user/rspec.rb

@@ -4,9 +4,9 @@ require 'rspec/core'
 
 RSpec.configure do |config|
 
-  config.include SwitchUser::RSpecFeatureHelpers, :type => :feature
+  config.include SwitchUser::RSpecFeatureHelpers, type: :feature
 
-  config.before(:each, :type => :feature) do
+  config.before(:each, type: :feature) do
     allow_any_instance_of(SwitchUserController).to receive(:available?).and_return(true)
   end
 

data/lib/switch_user/rspec/feature_helpers.rb

@@ -3,7 +3,7 @@ module SwitchUser
 
     class InvalidArgument < StandardError; end
 
-    def switch_user(user_record_or_scope, user_id=nil)
+    def switch_user(user_record_or_scope, user_id = nil)
       _user_scope =
         case user_record_or_scope
         when ActiveRecord::Base

data/lib/switch_user/user_set.rb

@@ -9,8 +9,8 @@ module SwitchUser
     end
 
     def self.users
-      init_from_config.flat_map {|user_set|
-        user_set.users.map {|user| Record.build(user, user_set) }
+      init_from_config.flat_map { |user_set|
+        user_set.users.map { |user| Record.build(user, user_set) }
       }
     end
 
@@ -24,7 +24,7 @@ module SwitchUser
     end
 
     def find_user(id)
-      Record.build(users.where(:id => id).first, self)
+      Record.build(users.where(id: id).first, self)
     end
     alias :[] :find_user
 

data/lib/switch_user/version.rb

@@ -1,3 +1,3 @@
 module SwitchUser
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/spec/controllers/switch_user_controller_spec.rb

@@ -2,27 +2,27 @@ require 'spec_helper'
 require 'switch_user'
 require 'switch_user_controller'
 
-RSpec.describe SwitchUserController, :type => :controller do
+RSpec.describe SwitchUserController, type: :controller do
   before do
     SwitchUser.provider = :dummy
   end
 
-  let(:admin) { double(:admin, :admin? => true) }
+  let(:admin) { double(:admin, admin?: true) }
   let(:provider) { double(:provider,
-                        :original_user => admin,
-                        :current_user => nil)
+                        original_user: admin,
+                        current_user: nil)
   }
   describe "#set_current_user" do
     it "redirects the user to the specified location" do
-      SwitchUser.redirect_path = lambda {|_,_| "/path"}
+      SwitchUser.redirect_path = ->(_, _) { "/path" }
       allow(controller).to receive(:available?).and_return(true)
-      get :set_current_user, :scope_identifier => "user_1"
+      get :set_current_user, params: { scope_identifier: "user_1" }
 
       expect(response).to redirect_to("/path")
     end
 
     it "denies access according to the guard block" do
-      SwitchUser.controller_guard = lambda {|_,_,_| false }
+      SwitchUser.controller_guard = ->(_, _, _) { false }
       expect {
         get :set_current_user
       }.to raise_error(ActionController::RoutingError)
@@ -30,9 +30,7 @@ RSpec.describe SwitchUserController, :type => :controller do
 
     describe "requests with a privileged original_user" do
       before do
-        SwitchUser.controller_guard = lambda {|current_user, _, original_user|
-          current_user.try(:admin?) || original_user.try(:admin?)
-        }
+        SwitchUser.controller_guard = ->(current_user, _, original_user) { current_user.try(:admin?) || original_user.try(:admin?) }
       end
       it "allows access using the original_user param" do
         allow(controller).to receive(:provider).and_return(provider)
@@ -54,18 +52,18 @@ RSpec.describe SwitchUserController, :type => :controller do
     it "can remember the current user" do
       expect(provider).to receive(:remember_current_user).with(true)
 
-      get :remember_user, :remember => "true"
+      get :remember_user, params: { remember: "true" }
     end
     it "can forget the current user" do
       expect(provider).to receive(:remember_current_user).with(false)
 
-      get :remember_user, :remember => "false"
+      get :remember_user, params: { remember: "false" }
     end
     it "does nothing if switch_back is not enabled" do
       SwitchUser.switch_back = false
       expect(provider).not_to receive(:remember_current_user)
 
-      get :remember_user, :remember => "true"
+      get :remember_user, params: { remember: "true" }
     end
   end
 end

data/spec/helpers/switch_user_helper_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 require 'switch_user'
 require 'switch_user_helper'
 
-RSpec.describe SwitchUserHelper, :type => :helper do
+RSpec.describe SwitchUserHelper, type: :helper do
   before do
     SwitchUser.provider = :dummy
   end
 
-  let(:user) { double(:user, :id => 1) }
-  let(:admin) { double(:admin, :id => 1) }
+  let(:user) { double(:user, id: 1) }
+  let(:admin) { double(:admin, id: 1) }
   let(:provider) {
     _provider = SwitchUser::Provider::Dummy.new(controller)
     _provider
@@ -16,8 +16,8 @@ RSpec.describe SwitchUserHelper, :type => :helper do
 
   describe "#switch_user_select" do
     let(:guest_record) { SwitchUser::GuestRecord.new }
-    let(:user_record) { double(:user_record, :user => user, :scope => :user, :label => 'user1', :scope_id => 'user_1') }
-    let(:admin_record) { double(:admin_record, :user => admin, :scope => :admin, :label => 'admin1', :scope_id => 'admin_1') }
+    let(:user_record) { double(:user_record, user: user, scope: :user, label: 'user1', scope_id: 'user_1') }
+    let(:admin_record) { double(:admin_record, user: admin, scope: :admin, label: 'admin1', scope_id: 'admin_1') }
 
     let(:guest_option_tags) { %Q^<optgroup label="Guest"><option value="">Guest</option></optgroup>^ }
     let(:user_option_tags) { %Q^<optgroup label="User"><option value="user_1">user1</option></optgroup>^ }
@@ -125,7 +125,7 @@ RSpec.describe SwitchUserHelper, :type => :helper do
 
   describe "#user_tag_value" do
     it "for user" do
-      user = double(:user, :id => 1)
+      user = double(:user, id: 1)
 
       expect(helper.send(:user_tag_value, user, :id, :user)).to eq('user_1')
     end
@@ -134,13 +134,13 @@ RSpec.describe SwitchUserHelper, :type => :helper do
   describe "#user_tag_label" do
     it "when name has call method" do
       user = double(:user)
-      name = ->(user){ 'user1' }
+      name = ->(user) { 'user1' }
 
       expect(helper.send(:user_tag_label, user, name)).to eq('user1')
     end
 
     it "when name not has call method" do
-      user = double(:name, :name => 'user1')
+      user = double(:name, name: 'user1')
       name = :name
 
       expect(helper.send(:user_tag_label, user, name)).to eq('user1')

data/spec/integration/switch_user_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-RSpec.describe "Using SwitchUser", :type => :request do
-  let(:user) { User.create!(:email => "foo@bar.com", :admin => true) }
-  let(:other_user) { User.create!(:email => "other@bar.com", :admin => false) }
+RSpec.describe "Using SwitchUser", type: :request do
+  let(:user) { User.create!(email: "foo@bar.com", admin: true) }
+  let(:other_user) { User.create!(email: "other@bar.com", admin: false) }
 
   before do
     SwitchUser.reset_config
     SwitchUser.provider = :session
-    SwitchUser.controller_guard = lambda { |current_user, request| Rails.env.test? }
-    SwitchUser.redirect_path = lambda {|_,_| "/dummy/open"}
+    SwitchUser.controller_guard = ->(current_user, request) { Rails.env.test? }
+    SwitchUser.redirect_path = ->(_, _) { "/dummy/open" }
   end
 
   it "signs a user in using switch_user" do
@@ -27,18 +27,16 @@ RSpec.describe "Using SwitchUser", :type => :request do
   context "using switch_back" do
     before do
       SwitchUser.switch_back = true
-      SwitchUser.controller_guard = lambda { |current_user, request, original_user|
-        current_user && current_user.admin? || original_user && original_user.admin?
-      }
+      SwitchUser.controller_guard = ->(current_user, request, original_user) { current_user && current_user.admin? || original_user && original_user.admin? }
     end
 
-    it "can switch back to a different user" do
+    it "can switch back to a different user through remember_user endpoint" do
       # login
-      post "/login", :id => user.id
+      post "/login", params: { id: user.id }
       follow_redirect!
 
       # have SwitchUser remember us
-      get "/switch_user/remember_user", :remember => true
+      get "/switch_user/remember_user", params: { remember: true }
       expect(session["original_user_scope_identifier"]).to be_present
 
       # check that we can switch to another user
@@ -54,7 +52,30 @@ RSpec.describe "Using SwitchUser", :type => :request do
       expect(session["user_id"]).to eq user.id
 
       # check that we can be un-remembered
-      get "/switch_user/remember_user", :remember => false
+      get "/switch_user/remember_user", params: { remember: false }
+      expect(session["original_user"]).to be_nil
+    end
+
+    it "can switch back to a different user without hitting remember_user endpoint" do
+      # login
+      post "/login", params: { :id => user.id }
+      follow_redirect!
+
+      # check that we can switch to another user
+      get "/switch_user?scope_identifier=user_#{other_user.id}", params: { :remember => true }
+      expect(session["user_id"]).to eq other_user.id
+      expect(session["original_user_scope_identifier"]).to_not be_nil
+
+      # logout
+      get "/logout"
+      expect(session["user_id"]).to be_nil
+
+      # check that we can still switch to another user
+      get "/switch_user?scope_identifier=user_#{user.id}"
+      expect(session["user_id"]).to eq user.id
+
+      # check that we can be un-remembered
+      get "/switch_user/remember_user", params: { :remember => false }
       expect(session["original_user"]).to be_nil
     end
   end

data/spec/provider/devise_spec.rb

@@ -65,13 +65,13 @@ RSpec.describe SwitchUser::Provider::Devise do
 
   describe "#login_exclusive" do
     before do
-      allow(SwitchUser).to receive(:available_users).and_return({:user => nil, :admin => nil})
+      allow(SwitchUser).to receive(:available_users).and_return({ user: nil, admin: nil })
       provider.login(user, :admin)
-      provider.login_exclusive(user, :scope => "user")
+      provider.login_exclusive(user, scope: "user")
     end
 
     it "logs the user in" do
-      expect(provider.current_user).to eq user
+      expect(provider.current_user(:user)).to eq user
     end
 
     it "logs out other scopes" do
@@ -81,7 +81,7 @@ RSpec.describe SwitchUser::Provider::Devise do
 
   describe "#logout_all" do
     it "logs out users under all scopes" do
-      allow(SwitchUser).to receive(:available_users).and_return({:user => nil, :admin => nil})
+      allow(SwitchUser).to receive(:available_users).and_return({ user: nil, admin: nil })
       provider.login(user, :admin)
       provider.login(user, :user)
 
@@ -94,7 +94,7 @@ RSpec.describe SwitchUser::Provider::Devise do
 
   describe "#all_current_users" do
     it "pulls users from an alternate scope" do
-      allow(SwitchUser).to receive(:available_users).and_return({:user => nil, :admin => nil})
+      allow(SwitchUser).to receive(:available_users).and_return({ user: nil, admin: nil })
       provider.login(user, :admin)
 
       expect(provider.current_users_without_scope).to eq [user]

data/spec/rspec/feature_helpers_spec.rb

@@ -6,32 +6,32 @@ Capybara.app = MyApp::Application
 
 require 'switch_user/rspec'
 
-RSpec.feature "SwitchUser::RSpecFeatureHelpers", :type => :feature do
+RSpec.feature "SwitchUser::RSpecFeatureHelpers", type: :feature do
   background do
-    @user = User.create!(:email => "foo@bar.com", :admin => true)
-    @client = Client.create!(:email => "foo@bar.com")
+    @user = User.create!(email: "foo@bar.com", admin: true)
+    @client = Client.create!(email: "foo@bar.com")
   end
 
-  before(:each) do
-    allow(SwitchUser).to receive(:controller_guard).and_return(lambda{|current_user, request| true})
+  before(:example) do
+    allow(SwitchUser).to receive(:controller_guard).and_return(->(current_user, request) { true })
 
-    allow(SwitchUser).to receive(:available_users).and_return({:user => lambda { User.all }})
+    allow(SwitchUser).to receive(:available_users).and_return({ user: -> { User.all } })
 
-    allow(SwitchUser).to receive(:available_users_identifiers).and_return({:user => :id})
+    allow(SwitchUser).to receive(:available_users_identifiers).and_return({ user: :id })
 
-    allow(SwitchUser).to receive(:available_users_names).and_return({:user => :email})
+    allow(SwitchUser).to receive(:available_users_names).and_return({ user: :email })
   end
 
   scenario "when controller_guard return false" do
-    allow(SwitchUser).to receive(:controller_guard).and_return(lambda{|current_user, request| false})
+    allow(SwitchUser).to receive(:controller_guard).and_return(->(current_user, request) { false })
 
     expect do
       switch_user @user
-    end.to_not raise_error ActionController::RoutingError, /Do not try to hack us/
+    end.not_to raise_error
   end
 
   scenario "when controller_guard return false and controller call original available?" do
-    allow(SwitchUser).to receive(:controller_guard).and_return(lambda{|current_user, request| false})
+    allow(SwitchUser).to receive(:controller_guard).and_return(->(current_user, request) { false })
 
     allow_any_instance_of(SwitchUserController).to receive(:available?).and_call_original
 
@@ -43,20 +43,20 @@ RSpec.feature "SwitchUser::RSpecFeatureHelpers", :type => :feature do
   scenario "arg is @user, available_users is default, and available_users_identifiers is default" do
     expect do
       switch_user @user
-    end.to_not raise_error
+    end.not_to raise_error
   end
 
   scenario "arg is @user, available_users is default, and available_users_identifiers is {user: id}" do
-    allow(SwitchUser).to receive(:available_users_identifiers).and_return({user: :id})
+    allow(SwitchUser).to receive(:available_users_identifiers).and_return({ user: :id })
 
     expect do
       switch_user @user
-    end.to_not raise_error
+    end.not_to raise_error
   end
 
   scenario "arg is @user, available_users is default, and available_users_identifiers is {:client => :id}" do
-    allow(SwitchUser).to receive(:available_users_identifiers).and_return({:client => :id})
-    allow(SwitchUser).to receive(:available_users_names).and_return({:client => :email})
+    allow(SwitchUser).to receive(:available_users_identifiers).and_return({ client: :id })
+    allow(SwitchUser).to receive(:available_users_names).and_return({ client: :email })
 
     expect do
       switch_user @user
@@ -70,7 +70,7 @@ RSpec.feature "SwitchUser::RSpecFeatureHelpers", :type => :feature do
   end
 
   scenario "arg is @client, available_users is {:user => lambda { User.all }, :client => lambda {Client.all}}, and available_users_identifiers is default" do
-    allow(SwitchUser).to receive(:available_users).and_return({:user => lambda { User.all }, :client => lambda {Client.all}})
+    allow(SwitchUser).to receive(:available_users).and_return({ user: -> { User.all }, client: -> { Client.all } })
 
     expect do
       switch_user @client
@@ -78,20 +78,20 @@ RSpec.feature "SwitchUser::RSpecFeatureHelpers", :type => :feature do
   end
 
   scenario "arg is @client, available_users is {:user => lambda { User.all }, :client => lambda {Client.all}}, and available_users_identifiers is {:user => id, :client => id}" do
-    allow(SwitchUser).to receive(:available_users).and_return({:user => lambda { User.all }, :client => lambda {Client.all}})
+    allow(SwitchUser).to receive(:available_users).and_return({ user: -> { User.all }, client: -> { Client.all } })
 
-    allow(SwitchUser).to receive(:available_users_identifiers).and_return({:user => :id, :client => :id})
-    allow(SwitchUser).to receive(:available_users_names).and_return({:user => :email, :client => :email})
+    allow(SwitchUser).to receive(:available_users_identifiers).and_return({ user: :id, client: :id })
+    allow(SwitchUser).to receive(:available_users_names).and_return({ user: :email, client: :email })
 
     expect do
       switch_user @client
-    end.to_not raise_error
+    end.not_to raise_error
   end
 
   scenario "args is :user and @user.id, available_users is default, and available_users_identifiers is default" do
     expect do
       switch_user :user, @user.id
-    end.to_not raise_error
+    end.not_to raise_error
   end
 
   scenario "arg is :client and @client.id, available_users is default, and available_users_identifiers is default" do
@@ -121,7 +121,7 @@ RSpec.feature "SwitchUser::RSpecFeatureHelpers", :type => :feature do
   scenario "args is :user and 0, available_users is default, and available_users_identifiers is default" do
     expect do
       switch_user :user, 0
-    end.to_not raise_error
+    end.not_to raise_error
   end
 
 end

data/spec/spec_helper.rb

@@ -7,7 +7,7 @@ require 'pry'
 require 'awesome_print'
 
 RSpec.configure do |config|
-  config.filter_run :focus => true
+  config.filter_run focus: true
   config.run_all_when_everything_filtered = true
   config.use_transactional_fixtures = true
   config.expose_dsl_globally = false

data/spec/support/application.rb

@@ -27,18 +27,30 @@ class ApplicationController < ActionController::Base
 end
 
 class DummyController < ApplicationController
-  before_filter :require_user, :only => :protected
+  before_action :require_user, only: :protected
 
   def authenticated
-    render :text => current_user.inspect
+    if Rails.version.to_i >= 5
+      render plain: current_user.inspect
+    else
+      render text: current_user.inspect
+    end
   end
 
   def open
-    render :text => view_context.switch_user_select
+    if Rails.version.to_i >= 5
+      render plain: view_context.switch_user_select
+    else
+      render text: view_context.switch_user_select
+    end
   end
 
   def protected
-    render :text => view_context.switch_user_select
+    if Rails.version.to_i >= 5
+      render plain: view_context.switch_user_select
+    else
+      render text: view_context.switch_user_select
+    end
   end
 end
 
@@ -55,13 +67,13 @@ module MyApp
 end
 Rails.application.initialize!
 Rails.application.routes.draw do
-  get 'dummy/protected', :to => "dummy#protected"
-  get 'dummy/open', :to => "dummy#open"
-  post 'login', :to => "dummy#login"
-  get 'logout', :to => "dummy#logout"
-  get 'authenticated', :to => "dummy#authenticated"
-  get :switch_user, :to => 'switch_user#set_current_user'
-  get 'switch_user/remember_user', :to => 'switch_user#remember_user'
+  get 'dummy/protected', to: "dummy#protected"
+  get 'dummy/open', to: "dummy#open"
+  post 'login', to: "dummy#login"
+  get 'logout', to: "dummy#logout"
+  get 'authenticated', to: "dummy#authenticated"
+  get :switch_user, to: 'switch_user#set_current_user'
+  get 'switch_user/remember_user', to: 'switch_user#remember_user'
 end
 
 connection = ActiveRecord::Base.connection

data/spec/support/provider.rb

@@ -25,7 +25,7 @@ RSpec.shared_examples_for "a provider" do
   end
 
   it "knows if there are any users logged in" do
-    provider.login(user)
+    provider.login(user, :user)
 
     expect(provider.current_users_without_scope).to eq [user]
   end
@@ -36,7 +36,7 @@ RSpec.shared_examples_for "a provider" do
     provider.login_exclusive(other_user, scope: "user")
 
     expect(provider.original_user).to eq user
-    expect(provider.current_user).to eq other_user
+    expect(provider.current_user(:user)).to eq other_user
   end
 
   it "can forget the original_user" do

data/spec/switch_user/data_source_spec.rb

@@ -5,7 +5,7 @@ module SwitchUser
     describe '#all' do
       it 'aggregates multiple data_sources' do
         user = double(:user)
-        s1 = double(:s1, :all => [user])
+        s1 = double(:s1, all: [user])
         source = DataSources.new([s1, s1])
 
         expect(source.all).to eq [user, user]
@@ -15,8 +15,8 @@ module SwitchUser
     describe '#find_scope_id' do
       it 'can find a corresponding record across data sources' do
         user = double(:user)
-        s1 = double(:s1, :find_scope_id => nil)
-        s2 = double(:s2, :find_scope_id => user)
+        s1 = double(:s1, find_scope_id: nil)
+        s2 = double(:s2, find_scope_id: user)
         source = DataSources.new([s1, s2])
 
         expect(source.find_scope_id("user_10")).to eq user
@@ -25,7 +25,7 @@ module SwitchUser
   end
 
   RSpec.describe DataSource do
-    pending # it's tested in integration test, need to find a good way to test it here.
+    skip # it's tested in integration test, need to find a good way to test it here.
   end
 
   RSpec.describe GuestDataSource do

data/spec/switch_user/lambda_guard_spec.rb

@@ -8,10 +8,10 @@ module SwitchUser
         provider = double.as_null_object
         guard = SwitchUser::LambdaGuard.new(controller, provider)
 
-        SwitchUser.controller_guard = lambda {|a| a }
+        SwitchUser.controller_guard = ->(a) { a }
         expect(guard).to be_controller_available
 
-        SwitchUser.controller_guard = lambda {|a| !a }
+        SwitchUser.controller_guard = ->(a) { !a }
         expect(guard).not_to be_controller_available
       end
     end

data/spec/switch_user/user_loader_spec.rb

@@ -11,16 +11,16 @@ RSpec.describe SwitchUser::UserLoader do
 
   describe ".user" do
     before do
-      SwitchUser.available_users_identifiers = {:user => :id}
-      allow(User).to receive(:where).with(:id => "1").and_return(user_result)
+      SwitchUser.available_users_identifiers = { user: :id }
+      allow(User).to receive(:where).with(id: "1").and_return(user_result)
     end
     it "can be loaded from a scope and identifier" do
-      loaded_user = SwitchUser::UserLoader.prepare("user","1").user
+      loaded_user = SwitchUser::UserLoader.prepare("user", "1").user
 
       expect(loaded_user).to eq user
     end
     it "can be loaded by a passing an unprocessed scope identifier" do
-      loaded_user = SwitchUser::UserLoader.prepare(:scope_identifier => "user_1").user
+      loaded_user = SwitchUser::UserLoader.prepare(scope_identifier: "user_1").user
 
       expect(loaded_user).to eq user
     end
@@ -32,7 +32,7 @@ RSpec.describe SwitchUser::UserLoader do
   end
 
   it "returns a user" do
-    allow(User).to receive(:where).with(:id => 1).and_return(user_result)
+    allow(User).to receive(:where).with(id: 1).and_return(user_result)
 
     loader = SwitchUser::UserLoader.new("user", 1)
 
@@ -47,8 +47,8 @@ RSpec.describe SwitchUser::UserLoader do
   end
 
   it "loads a user with an alternate identifier column" do
-    allow(User).to receive(:where).with(:email => 2).and_return(user_result)
-    SwitchUser.available_users_identifiers = {:user => :email}
+    allow(User).to receive(:where).with(email: 2).and_return(user_result)
+    SwitchUser.available_users_identifiers = { user: :email }
 
     loader = SwitchUser::UserLoader.new("user", 2)
     expect(loader.user).to eq user

data/spec/switch_user/user_set_spec.rb

@@ -3,8 +3,8 @@ require 'switch_user/user_set'
 
 module SwitchUser
   RSpec.describe UserSet do
-    let!(:user) { User.create(:email => "test@example.com") }
-    let(:set) { UserSet.new(:user, :id, :email, lambda { User.all }) }
+    let!(:user) { User.create(email: "test@example.com") }
+    let(:set) { UserSet.new(:user, :id, :email, -> { User.all }) }
     after { User.delete_all }
     it "returns an object that knows it's scope, id and label" do
       found_user = set[user.id]
@@ -17,14 +17,14 @@ module SwitchUser
       expect(set.users).to eq [user]
     end
     it "chains the where on to the provided scope" do
-      set = UserSet.new(:user, :id, :email, lambda { User.all })
+      set = UserSet.new(:user, :id, :email, -> { User.all })
       expect(set.find_user(user.id).label).to eq user.email
     end
   end
   RSpec.describe UserSet::Record do
     it "correctly configures the record using the set" do
-      user = double(:user, :id => 100, :email => "test@example.com")
-      set = double(:set, :identifier  => :id, :label => :email, :scope => :user)
+      user = double(:user, id: 100, email: "test@example.com")
+      set = double(:set, identifier: :id, label: :email, scope: :user)
       record = UserSet::Record.build(user, set)
       expect(record.id).to eq 100
       expect(record.label).to eq "test@example.com"

data/switch_user.gemspec

@@ -28,6 +28,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "capybara"
 
   s.files        = `git ls-files`.split("\n")
-  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.executables  = `git ls-files`.split("\n").map { |f| f =~ /^bin\/(.*)/ ? $1 : nil }.compact
   s.require_path = 'lib'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switch_user
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Richard Huang
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-21 00:00:00.000000000 Z
+date: 2017-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -261,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: switch_user
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Easily switch current user to speed up development