ramon-devise 0.4.2

data/lib/devise/controllers/filters.rb

@@ -0,0 +1,111 @@
+module Devise
+  module Controllers
+    # Those filters are convenience methods added to ApplicationController to
+    # deal with Warden.
+    module Filters
+
+      def self.included(base)
+        base.class_eval do
+          helper_method :warden, :signed_in?, :devise_controller?,
+                        *Devise.mappings.keys.map { |m| [:"current_#{m}", :"#{m}_signed_in?"] }.flatten
+
+          # Use devise default_url_options. We have to declare it here to overwrite
+          # default definitions.
+          def default_url_options(options=nil)
+            Devise::Mapping.default_url_options
+          end
+        end
+      end
+
+      # The main accessor for the warden proxy instance
+      def warden
+        request.env['warden']
+      end
+
+      # Return true if it's a devise_controller. false to all controllers unless
+      # the controllers defined inside devise. Useful if you want to apply a before
+      # filter to all controller, except the ones in devise:
+      #
+      #   before_filter :my_filter, :unless => { |c| c.devise_controller? }
+      def devise_controller?
+        false
+      end
+
+      # Attempts to authenticate the given scope by running authentication hooks,
+      # but does not redirect in case of failures.
+      def authenticate(scope)
+        warden.authenticate(:scope => scope)
+      end
+
+      # Attempts to authenticate the given scope by running authentication hooks,
+      # redirecting in case of failures.
+      def authenticate!(scope)
+        warden.authenticate!(:scope => scope)
+      end
+
+      # Check if the given scope is signed in session, without running
+      # authentication hooks.
+      def signed_in?(scope)
+        warden.authenticated?(scope)
+      end
+
+      # Set the warden user with the scope, signing in the resource automatically,
+      # without running hooks.
+      def sign_in(scope, resource)
+        warden.set_user(resource, :scope => scope)
+      end
+
+      # Sign out based on scope.
+      def sign_out(scope, *args)
+        warden.user(scope) # Without loading user here, before_logout hook is not called
+        warden.raw_session.inspect # Without this inspect here. The session does not clear.
+        warden.logout(scope, *args)
+      end
+
+      # Define authentication filters and accessor helpers based on mappings.
+      # These filters should be used inside the controllers as before_filters,
+      # so you can control the scope of the user who should be signed in to
+      # access that specific controller/action.
+      # Example:
+      #
+      #   Maps:
+      #     User => :authenticatable
+      #     Admin => :authenticatable
+      #
+      #   Generated methods:
+      #     authenticate_user!  # Signs user in or redirect
+      #     authenticate_admin! # Signs admin in or redirect
+      #     user_signed_in?     # Checks whether there is an user signed in or not
+      #     admin_signed_in?    # Checks whether there is an admin signed in or not
+      #     current_user        # Current signed in user
+      #     current_admin       # Currend signed in admin
+      #     user_session        # Session data available only to the user scope
+      #     admin_session       # Session data available only to the admin scope
+      #
+      #   Use:
+      #     before_filter :authenticate_user!  # Tell devise to use :user map
+      #     before_filter :authenticate_admin! # Tell devise to use :admin map
+      #
+      Devise.mappings.each_key do |mapping|
+        class_eval <<-METHODS, __FILE__, __LINE__
+          def authenticate_#{mapping}!
+            warden.authenticate!(:scope => :#{mapping})
+          end
+
+          def #{mapping}_signed_in?
+            warden.authenticated?(:#{mapping})
+          end
+
+          def current_#{mapping}
+            @current_#{mapping} ||= warden.user(:#{mapping})
+          end
+
+          def #{mapping}_session
+            warden.session(:#{mapping})
+          end
+        METHODS
+      end
+
+    end
+  end
+end

data/lib/devise/controllers/helpers.rb

@@ -0,0 +1,130 @@
+module Devise
+  module Controllers
+    # Those helpers are used only inside Devise controllers and should not be
+    # included in ApplicationController since they all depend on the url being
+    # accessed.
+    module Helpers
+
+      def self.included(base)
+        base.class_eval do
+          helper_method :resource, :resource_name, :resource_class, :devise_mapping, :devise_controller?
+          hide_action   :resource, :resource_name, :resource_class, :devise_mapping, :devise_controller?
+
+          skip_before_filter *Devise.mappings.keys.map { |m| :"authenticate_#{m}!" }
+          before_filter :is_devise_resource?
+        end
+      end
+
+      # Gets the actual resource stored in the instance variable
+      def resource
+        instance_variable_get(:"@#{resource_name}")
+      end
+
+      # Proxy to devise map name
+      def resource_name
+        devise_mapping.name
+      end
+
+      # Proxy to devise map class
+      def resource_class
+        devise_mapping.to
+      end
+
+      # Attempt to find the mapped route for devise based on request path
+      def devise_mapping
+        @devise_mapping ||= Devise::Mapping.find_by_path(request.path)
+      end
+
+      # Overwrites devise_controller? to return true
+      def devise_controller?
+        true
+      end
+
+    protected
+
+      # Redirects to stored uri before signing in or the default path and clear
+      # return to.
+      def redirect_back_or_to(default)
+        redirect_to(return_to || default)
+        clear_return_to
+      end
+
+      # Access to scoped stored uri
+      def return_to
+        session[:"#{resource_name}.return_to"]
+      end
+
+      # Clear scoped stored uri
+      def clear_return_to
+        session[:"#{resource_name}.return_to"] = nil
+      end
+
+      # Checks for the existence of the resource root path. If it exists,
+      # returns it, otherwise returns the default root_path.
+      # Used after authenticating a user, confirming it's account or updating
+      # it's password, so we are able to redirect to scoped root paths.
+      # Examples (for a user scope):
+      #   map.user_root '/users', :controller => 'users' # creates user_root_path
+      #
+      #   map.namespace :users do |users|
+      #     users.root # creates user_root_path
+      #   end
+      def home_or_root_path
+        home_path = :"#{resource_name}_root_path"
+        respond_to?(home_path, true) ? send(home_path) : root_path
+      end
+
+      # Checks whether it's a devise mapped resource or not.
+      def is_devise_resource? #:nodoc:
+        raise ActionController::UnknownAction unless devise_mapping && devise_mapping.allows?(controller_name)
+      end
+
+      # Sets the resource creating an instance variable
+      def resource=(new_resource)
+        instance_variable_set(:"@#{resource_name}", new_resource)
+      end
+
+      # Build a devise resource without setting password and password confirmation fields.
+      def build_resource
+        self.resource ||= begin
+          attributes = params[resource_name].try(:except, :password, :password_confirmation)
+          resource_class.new(attributes)
+        end
+      end
+
+      # Helper for use in before_filters where no authentication is required.
+      #
+      # Example:
+      #   before_filter :require_no_authentication, :only => :new
+      def require_no_authentication
+        redirect_to home_or_root_path if warden.authenticated?(resource_name)
+      end
+
+      # Sets the flash message with :key, using I18n. By default you are able
+      # to setup your messages using specific resource scope, and if no one is
+      # found we look to default scope.
+      # Example (i18n locale file):
+      #
+      #   en:
+      #     devise:
+      #       passwords:
+      #         #default_scope_messages - only if resource_scope is not found
+      #         user:
+      #           #resource_scope_messages
+      #
+      # Please refer to README or en.yml locale file to check what messages are
+      # available.
+      def set_flash_message(key, kind, now=false)
+        flash_hash = now ? flash.now : flash
+        flash_hash[key] = I18n.t(:"#{resource_name}.#{kind}",
+                            :scope => [:devise, controller_name.to_sym], :default => kind)
+      end
+
+      # Shortcut to set flash.now message. Same rules applied from set_flash_message
+      def set_now_flash_message(key, kind)
+        set_flash_message(key, kind, true)
+      end
+
+    end
+  end
+end

data/lib/devise/controllers/url_helpers.rb

@@ -0,0 +1,49 @@
+module Devise
+  module Controllers
+    # Create url helpers to be used with resource/scope configuration. Acts as
+    # proxies to the generated routes created by devise.
+    # Resource param can be a string or symbol, a class, or an instance object.
+    # Example using a :user resource:
+    #
+    #   new_session_path(:user)      => new_user_session_path
+    #   session_path(:user)          => user_session_path
+    #   destroy_session_path(:user)  => destroy_user_session_path
+    #
+    #   new_password_path(:user)     => new_user_password_path
+    #   password_path(:user)         => user_password_path
+    #   edit_password_path(:user)    => edit_user_password_path
+    #
+    #   new_confirmation_path(:user) => new_user_confirmation_path
+    #   confirmation_path(:user)     => user_confirmation_path
+    #
+    # Those helpers are added to your ApplicationController.
+    module UrlHelpers
+
+      [:session, :password, :confirmation].each do |module_name|
+        [:path, :url].each do |path_or_url|
+          actions = [ nil, :new_ ]
+          actions << :edit_    if module_name == :password
+          actions << :destroy_ if module_name == :session
+
+          actions.each do |action|
+            class_eval <<-URL_HELPERS
+              def #{action}#{module_name}_#{path_or_url}(resource, *args)
+                resource = case resource
+                  when Symbol, String
+                    resource
+                  when Class
+                    resource.name.underscore
+                  else
+                    resource.class.name.underscore
+                end
+
+                send("#{action}\#{resource}_#{module_name}_#{path_or_url}", *args)
+              end
+            URL_HELPERS
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/devise/failure.rb

@@ -0,0 +1,38 @@
+module Devise
+  module Failure
+    mattr_accessor :default_url
+
+    # Failure application that will be called every time :warden is thrown from
+    # any strategy or hook. Responsible for redirect the user to the sign in
+    # page based on current scope and mapping. If no scope is given, redirect
+    # to the default_url.
+    def self.call(env)
+      options = env['warden.options']
+      scope   = options[:scope]
+      params  = case env['warden'].try(:message)
+        when Symbol
+          { env['warden'].message => true }
+        when String
+          { :message => env['warden'].message }
+        else
+          options[:params]
+      end
+
+      env['warden'].logout
+
+      redirect_path = if mapping = Devise.mappings[scope]
+        "#{mapping.parsed_path}/#{mapping.path_names[:sign_in]}"
+      else
+        "/#{default_url}"
+      end
+
+      headers = {}
+      headers["Location"] = redirect_path
+      headers["Location"] << "?" << Rack::Utils.build_query(params) if params
+      headers["Content-Type"] = 'text/plain'
+
+      message = options[:message] || "You are being redirected to #{redirect_path}"
+      [302, headers, [message]]
+    end
+  end
+end

data/lib/devise/hooks/confirmable.rb

@@ -0,0 +1,11 @@
+# Each time the user is set we verify if it is still able to really sign in.
+# This is done by checking the time frame the user is able to sign in without
+# confirming it's account. If the user has not confirmed it's account during
+# this time frame, he/she will not able to sign in anymore.
+Warden::Manager.after_set_user do |record, auth, options|
+  if record && record.respond_to?(:active?) && !record.active?
+    scope = options[:scope]
+    auth.logout(scope)
+    throw :warden, :scope => scope, :params => { :unconfirmed => true }
+  end
+end

data/lib/devise/hooks/rememberable.rb

@@ -0,0 +1,27 @@
+# After authenticate hook to verify if the user in the given scope asked to be
+# remembered while he does not sign out. Generates a new remember token for
+# that specific user and adds a cookie with this user info to sign in this user
+# automatically without asking for credentials. Refer to rememberable strategy
+# for more info.
+Warden::Manager.after_authentication do |record, auth, options|
+  scope = options[:scope]
+  remember_me = auth.params[scope].try(:fetch, :remember_me, nil)
+
+  if Devise::TRUE_VALUES.include?(remember_me) && record.respond_to?(:remember_me!)
+    record.remember_me!
+    auth.cookies['remember_token'] = {
+      :value => record.class.serialize_into_cookie(record),
+      :expires => record.remember_expires_at
+    }
+  end
+end
+
+# Before logout hook to forget the user in the given scope, only if rememberable
+# is activated for this scope. Also clear remember token to ensure the user
+# won't be remembered again.
+Warden::Manager.before_logout do |record, auth, scope|
+  if record.respond_to?(:forget_me!)
+    record.forget_me!
+    auth.cookies.delete('remember_token')
+  end
+end

data/lib/devise/locales/en.yml

@@ -0,0 +1,18 @@
+en:
+  devise:
+    sessions:
+      signed_in: 'Signed in successfully.'
+      signed_out: 'Signed out successfully.'
+      unauthenticated: 'You need to sign in or sign up before continuing.'
+      unconfirmed: 'You have to confirm your account before continuing.'
+      invalid: 'Invalid email or password.'
+    passwords:
+      send_instructions: 'You will receive an email with instructions about how to reset your password in a few minutes.'
+      updated: 'Your password was changed successfully. You are now signed in.'
+    confirmations:
+      send_instructions: 'You will receive an email with instructions about how to confirm your account in a few minutes.'
+      confirmed: 'Your account was successfully confirmed. You are now signed in.'
+    mailer:
+      confirmation_instructions: 'Confirmation instructions'
+      reset_password_instructions: 'Reset password instructions'
+

data/lib/devise/mapping.rb

@@ -0,0 +1,120 @@
+module Devise
+  # Responsible for handling devise mappings and routes configuration. Each
+  # resource configured by devise_for in routes is actually creating a mapping
+  # object. You can refer to devise_for in routes for usage options.
+  #
+  # The required value in devise_for is actually not used internally, but it's
+  # inflected to find all other values.
+  #
+  #   map.devise_for :users
+  #   mapping = Devise.mappings[:user]
+  #
+  #   mapping.name #=> :user
+  #   # is the scope used in controllers and warden, given in the route as :singular.
+  #
+  #   mapping.as   #=> "users"
+  #   # how the mapping should be search in the path, given in the route as :as.
+  #
+  #   mapping.to   #=> User
+  #   # is the class to be loaded from routes, given in the route as :class_name.
+  #
+  #   mapping.for  #=> [:authenticatable]
+  #   # is the modules included in the class
+  #
+  class Mapping #:nodoc:
+    attr_reader :name, :as, :path_names, :path_prefix
+
+    # Loop through all mappings looking for a map that matches with the requested
+    # path (ie /users/sign_in). If a path prefix is given, it's taken into account.
+    def self.find_by_path(path)
+      Devise.mappings.each_value do |mapping|
+        route = path.split("/")[mapping.as_position]
+        return mapping if mapping.as == route.to_sym
+      end
+      nil
+    end
+
+    # Default url options which can be used as prefix.
+    def self.default_url_options
+      {}
+    end
+
+    def initialize(name, options) #:nodoc:
+      options.assert_valid_keys(:class_name, :as, :path_names, :singular, :path_prefix)
+
+      @as    = (options[:as] || name).to_sym
+      @klass = (options[:class_name] || name.to_s.classify).to_s
+      @name  = (options[:singular] || name.to_s.singularize).to_sym
+      @path_names  = options[:path_names] || {}
+      @path_prefix = options[:path_prefix] || ""
+      @path_prefix << "/" unless @path_prefix[-1] == ?/
+
+      setup_path_names
+    end
+
+    # Return modules for the mapping.
+    def for
+      @for ||= to.devise_modules
+    end
+
+    # Reload mapped class each time when cache_classes is false.
+    def to
+      return @to if @to
+      klass = @klass.constantize
+      @to = klass if Rails.configuration.cache_classes
+      klass
+    end
+
+    # Check if the respective controller has a module in the mapping class.
+    def allows?(controller)
+      self.for.include?(CONTROLLERS[controller.to_sym])
+    end
+
+    # Return in which position in the path prefix devise should find the as mapping.
+    def as_position
+      self.path_prefix.count("/")
+    end
+
+    # Returns the raw path using path_prefix and as.
+    def raw_path
+      path_prefix + as.to_s
+    end
+
+    # Returns the parsed path. If you need meta information in your path_prefix,
+    # you should overwrite this method to use it. The only information supported
+    # by default is I18n.locale.
+    #
+    def parsed_path
+      returning raw_path do |path|
+        self.class.default_url_options.each do |key, value|
+          path.gsub!(key.inspect, value.to_s)
+        end
+      end
+    end
+
+    # Create magic predicates for verifying what module is activated by this map.
+    # Example:
+    #
+    #   def confirmable?
+    #     self.for.include?(:confirmable)
+    #   end
+    #
+    ALL.each do |m|
+      class_eval <<-METHOD, __FILE__, __LINE__
+        def #{m}?
+          self.for.include?(:#{m})
+        end
+      METHOD
+    end
+
+    private
+
+      # Configure default path names, allowing the user overwrite defaults by
+      # passing a hash in :path_names.
+      def setup_path_names
+        [:sign_in, :sign_out, :password, :confirmation].each do |path_name|
+          @path_names[path_name] ||= path_name.to_s
+        end
+      end
+  end
+end