action_interceptor 0.5.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44ab9883cb1bb5fcebed393839f0e9c59922793a
-  data.tar.gz: d3837244011aaf89a4a280f116505bfe6ed503fa
+  metadata.gz: ce38ce707a8334bb66b8acf906521d3b3767d4b8
+  data.tar.gz: 27684b0414dbd5d8c7b7e1eeb89c7595afaa8c94
 SHA512:
-  metadata.gz: b5701a304ec6e2782e31a0d1795b22ee335fa1b5bfe46ae9a518ed4d75979ed025e2d107380908519ec4698bc1322a2796d195d7ce6150e8a693d6eb4f05b495
-  data.tar.gz: ea4bed34a80eaa1def6bb9ce09f88df0539357b67dc1ba35ece2ed502856cec109c63e3db043988e3c2287f07e534ad07c743322b4f32a8011dc685d79f5433b
+  metadata.gz: 77ae4ca36711165371f3001101bf52e6f2cb3710bdcbaf17f2d48ee7c210c0f2130fb19e0ec8478cfebac4f73e01f173d66338e1cf296775c5c10c13119c99e3
+  data.tar.gz: 489a4126575dd1928b1840b420b38896e55e5a6de05403de093115657d6385ec290f8a4ad8318239c0361208dd781a13ca9683966af3396c2eb7391162a08010

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2014 Rice University
+Copyright 2014-2015 Rice University
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -18,4 +18,3 @@ 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

@@ -4,11 +4,11 @@
 [![Build Status](https://travis-ci.org/openstax/action_interceptor.svg?branch=master)](https://travis-ci.org/openstax/action_interceptor)
 [![Code Climate](https://codeclimate.com/github/openstax/action_interceptor.png)](https://codeclimate.com/github/openstax/action_interceptor)
 
-Action Interceptor is a Rails engine that makes it easy to have controllers intercept
-actions from other controllers, have users perform a task and then return them to where
-they were when the interception happened.
+Action Interceptor is a Rails engine that makes it easy to store and
+retrieve return url's across multiple requests and different controllers.
 
-This can be used, for example, for registration, authentication, signing terms of use, etc.
+This can be used, for example, for registration, authentication,
+signing terms of use, etc.
 
 ## Installation
 
@@ -33,121 +33,44 @@ $ rake action_interceptor:install
 
 In case Action Interceptor is completely unable to determine which page a user
 came from (should rarely happen if properly configured), it will send the user
-to your application or gem's root (the '/' path).
+to your application's root url.
 
 ## Usage
 
-Interceptors are blocks of code that are declared in Action Interceptor's
-initializer. They execute in the context of your controllers and work
-very much like before_filters.
+Before your before_filter or controller redirects the user to the
+login/registration/terms of use page, call `store_url`
+to store the current url.
 
-For example, the following interceptor could be used to ensure that users
-have filled out a registration form:
+In the login/registration/terms of use page, call `store_fallback`
+to store the http referer, in case the user reached that page
+through an unexpected path.
 
-```rb
-interceptor :registration do
-
-  return if current_user.try(:is_registered?)
-
-  respond_to do |format|
-    format.html { redirect_to register_path }
-    format.json { head(:forbidden) }
-  end
-
-end
-```
-
-What makes interceptors different from before_filters is that they will
-save the user's current url before redirecting. This is done through
-signed url params by default, falling back to session variables if those
-params are absent or invalid.
-
-Once declared, you can use an interceptor in any controller. For example,
-you might want to ensure that all logged in users have to complete
-a form before using your site. In that case, you could add the following
-to your `ApplicationController`:
-
-```rb
-class ApplicationController < ActionController::Base
+When the user is done with their task, call `redirect_back`
+to send them back to where they were before.
 
-  interceptor :registration
-
-end
-```
-
-The controllers your interceptors redirect to should
-call the `acts_as_interceptor` method:
-
-```rb
-class RegistrationsController < ApplicationController
-
-  acts_as_interceptor
-
-  skip_interceptor :registration, only: [:new, :create]
-
-end
-```
-
-As shown above, interceptions work like before_filters and
-can be skipped using the skip_interceptor method.
+All of those methods can also take an options hash,
+where you can pass a `:key` argument.
+If your site uses multiple different redirects, you can specify
+a different `:key` for each in order to have them not overwrite each other.
 
 Just by including the gem in your app, the following convenience methods
 will also be added to all controllers as helper methods, so they will also
-be available in views: `current_page?(url)`, `current_url`, `current_url_hash`,
-`with_interceptor(&block)` and `without_interceptor(&block)`.
-
-- `with_interceptor(&block)` executes the given block:
-  - Adding the intercepted URL param to all links and redirects
-  - As if it was declared in the context of `self`
-- `without_interceptor(&block)` executes the given block:
-  - With the default URL params for all links and redirects
-  - As if it was declared in the context of `self`
-
-- `current_url_hash` returns a hash containing the `intercepted_url_key` and the
-  `current_url`, signed and encrypted.
+be available in views: `current_page?(url)`, `current_url` and `stored_url`.
 
-- And the following methods, backported from Rails 4:
   - `current_url` returns the current url.
   - `current_page?(url)` returns true iif the given url is the `current_url`.
-
-When called, the `acts_as_interceptor` method will ensure the following:
-
-- The `url_options` method for that controller will be overriden, causing all
-  links and redirects for the controller and associated views to include
-  the signed return url. This behavior can be skipped by passing
-  `:override_url_options => false` to the `acts_as_interceptor` call,
-  like so: `acts_as_interceptor :override_url_options => false`.
-  In that case, you are responsible for wrapping any internal links and
-  redirects in `with_interceptor` blocks.
-
-- The following convenience methods will be added to the controller:
-  `redirect_back(options = {})`, `intercepted_url`,
-  `intercepted_url=` and `intercepted_url_hash`.
-  These methods have the following behavior:
-
-  - redirect_back(options = {}) redirects the user back to where the
-    interception occurred, passing the given options to the redirect method.
-
-  - `intercepted_url` returns the intercepted url. Can be used in views to make
-    links that redirect the user back to where the interception happened.
-
-  - `intercepted_url=` can be used to overwrite the intercepted url, if needed.
-
-  - `intercepted_url_hash` returns a hash containing the `interceptor_url_key`
-    and the signed `intercepted_url`.
-
-When users complete the given task, use the following method to
-redirect them back to where the interception occurred:
-
-```rb
-redirect_back
-```
-
-Alternatively, you can use `intercepted_url` in views:
-
-```erb
-<%= link_to 'Back', intercepted_url %>
-```
+  - `stored_url` returns the stored url.
+
+The following convenience methods are also added to controllers:
+`store_url`, `store_fallback`, `delete_stored_url` and `redirect_back`.
+These methods have the following behavior:
+
+  - `store_url` stores the current url
+    (or specify the url using the `:url` option).
+  - `store_fallback` stores the http referer only if no stored url
+    is already present (or specify the fallback url using `:url` option).
+  - `delete_stored_url` deletes the stored url.
+  - `redirect_back` redirects the user to the stored url and deletes it.
 
 ## Contributing
 

data/config/initializers/action_interceptor.rb

@@ -1,51 +1,25 @@
-ActionInterceptor.configure do
-  # The following options can be set in this initializer
-  # or passed directly to acts_as_interceptor:
+ActionInterceptor.configure do |config|
+  # default_strategies
+  # Type: Array
+  # Array of the default strategies used to store and retrieve url's.
+  # When storing a url, all strategies will be used.
+  # When attempting to retrieve stored url's, strategies will be called
+  # in order until one of them returns a non-blank string.
+  # Available strategies: :session
+  # Default: [ :session ]
+  config.default_strategies = [ :session ]
 
-  # intercepted_url_key(key)
-  # Type: Method
-  # Arguments: key (Symbol)
-  # The parameter/session variable that will hold the intercepted URL.
-  # Default: :r
-  intercepted_url_key :r
-
-  # override_url_options(bool)
-  # Type: Method
-  # Arguments: bool (Boolean)
-  # If true, the url_options method will be overriden for any controller that
-  # `acts_as_interceptor`. This option causes all links and redirects from any
-  # such controller to include a parameter containing the intercepted_url_key
-  # and the intercepted url.
-  # If set to false, you must use the interceptor_url_options method to obtain
-  # the hash and pass it to any links or redirects that need to use it.
-  # Default: true
-  override_url_options true
-
-  # skip_session(bool)
-  # Type: Method
-  # Arguments: bool (Boolean)
-  # If set to false, ActionInterceptor will store and use the intercepted url
-  # in the session object, under the :interceptor key. ActionInterceptor will
-  # attempt to retrieve the intercepted url from the url params, session and
-  # referer, in this order.
-  # If true, ActionInterceptor will ignore the session, so only the url params
-  # and the referer will be checked, in this order.
-  # Useful if you expect to get redirects that do not or cannot properly set
-  # the url params and must rely on the referer instead.
-  # Default: false
-  skip_session false
+  # default_url
+  # Type: String
+  # If no stored url is found, or if the stored url would cause a self redirect,
+  # controller methods will use (redirect to) this url instead.
+  # Default: nil (root_url)
+  config.default_url = nil
 
-  # The following options can only be set in this initializer:
-
-  # interceptor(interceptor_name, &block)
-  # Type: Method
-  # Arguments: interceptor name (Symbol or String),
-  #            &block (Proc)
-  # Defines an interceptor.
-  # Default: none
-  # Example: interceptor :my_name do
-  #            redirect_to my_action_users_url if some_condition
-  #          end
-  #
-  #          (Conditionally redirects to :my_action in UsersController)
+  # default_key
+  # Type: Symbol
+  # The default key under which url's are stored in the session.
+  # Used if the :key option is not provided when storing or retrieving url's.
+  # Default: :r
+  config.default_key = :r
 end

data/lib/action_interceptor.rb

@@ -1,29 +1,16 @@
 require 'action_interceptor/engine'
+require 'action_interceptor/configuration'
+require 'action_interceptor/strategies'
+require 'action_interceptor/strategies/session'
 
 module ActionInterceptor
 
-  DEFAULT_CONFIG = {}
-
-  INTERCEPTOR_ATTRIBUTES = [:intercepted_url_key,
-                            :override_url_options,
-                            :skip_session]
-
-  INTERCEPTOR_ATTRIBUTES.each do |attribute|
-    define_singleton_method(attribute) do |value|
-      DEFAULT_CONFIG[attribute] = value
-    end
-  end
-
-  def self.interceptors
-    @interceptors ||= {}
-  end
-
-  def self.interceptor(interceptor_name, &block)
-    interceptors.merge!({interceptor_name => block})
+  def self.config
+    @config ||= Configuration.new
   end
 
   def self.configure(&block)
-    instance_exec &block
+    yield config
   end
 
 end

data/lib/action_interceptor/action_controller/base.rb

@@ -0,0 +1,94 @@
+module ActionInterceptor
+  module ActionController
+    module Base
+
+      def self.included(base)
+        base.helper_method :current_page?, :current_url, :stored_url
+      end
+
+      protected
+
+      def current_page?(url)
+        # Return true for blank (blank links redirect to the same page)
+        return true if url.blank?
+
+        uri = URI(url)
+        uri.path == request.path && (
+          uri.relative? || (
+            uri.host == request.host && uri.port == request.port
+          )
+        )
+      end
+
+      def current_url
+        "#{request.protocol}#{request.host_with_port}#{request.fullpath}"
+      end
+
+      # Stores the given url or the current url
+      def store_url(options = {})
+        strats = ActionInterceptor::Strategies.find_all(self,
+                                                        options[:strategies])
+        key = options[:key] || ActionInterceptor.config.default_key
+
+        url = options.has_key?(:url) ? options[:url] : current_url
+
+        strats.each do |strat|
+          strat.set(key, url)
+        end
+
+        url
+      end
+
+      # Retrieves the stored url
+      def stored_url(options = {})
+        strats = ActionInterceptor::Strategies.find_all(self,
+                                                        options[:strategies])
+        key = options[:key] || ActionInterceptor.config.default_key
+
+        strats.each do |strat|
+          url = strat.get(key)
+          return url unless url.blank?
+        end
+
+        nil
+      end
+
+      # Stores the given url or the referer if no stored url is present
+      def store_fallback(options = {})
+        store_url({url: request.referer}.merge(options)) \
+          if stored_url(options).blank?
+      end
+
+      # Deletes to the stored url
+      def delete_stored_url(options = {})
+        strats = ActionInterceptor::Strategies.find_all(self,
+                                                        options[:strategies])
+        key = options[:key] || ActionInterceptor.config.default_key
+
+        strats.each do |strat|
+          strat.unset(key)
+        end
+
+        nil
+      end
+
+      # Redirects to the stored url and deletes it from storage
+      def redirect_back(options = {})
+        interceptor_options = options.slice(:key, :strategies)
+        redirect_options = options.except(:key, :strategies)
+
+        url = stored_url(interceptor_options)
+        delete_stored_url(interceptor_options)
+
+        # Prevent self redirects
+        url = (ActionInterceptor.config.default_url || main_app.root_url) \
+                if current_page?(url)
+
+        redirect_to url, redirect_options
+      end
+
+    end
+  end
+end
+
+ActionController::Base.send :include, ActionInterceptor::ActionController::Base

data/lib/action_interceptor/configuration.rb

@@ -0,0 +1,7 @@
+module ActionInterceptor
+  class Configuration
+
+    attr_accessor :default_strategies, :default_url, :default_key
+
+  end
+end

data/lib/action_interceptor/engine.rb

@@ -1,6 +1,4 @@
-require 'action_interceptor/common'
-require 'action_interceptor/action_controller'
-require 'action_interceptor/action_mailer'
+require 'action_interceptor/action_controller/base'
 
 module ActionInterceptor
   class Engine < ::Rails::Engine

data/lib/action_interceptor/strategies.rb

@@ -0,0 +1,19 @@
+module ActionInterceptor
+  module Strategies
+
+    def self.register(name, strategy_class)
+      @strategy_map ||= HashWithIndifferentAccess.new
+      @strategy_map[name] = strategy_class
+    end
+
+    def self.find(controller, name)
+      @strategy_map[name].new(controller)
+    end
+
+    def self.find_all(controller, names)
+      names ||= ActionInterceptor.config.default_strategies
+      names.collect{|name| find(controller, name)}
+    end
+
+  end
+end

data/lib/action_interceptor/strategies/session.rb

@@ -0,0 +1,28 @@
+require 'action_interceptor/strategies'
+
+module ActionInterceptor
+  module Strategies
+    class Session
+
+      def initialize(controller)
+        @session = controller.session
+      end
+
+      def set(key, string)
+        @session[key] = string
+      end
+
+      def get(key)
+        @session[key]
+      end
+
+      def unset(key)
+        @session.delete(key)
+      end
+
+    end
+  end
+end
+
+ActionInterceptor::Strategies.register(:session,
+                                       ActionInterceptor::Strategies::Session)