devise 0.1.0

data/app/views/confirmations/new.html.erb

@@ -0,0 +1,16 @@
+<h2>Resend confirmation instructions</h2>
+
+<% form_for resource_name, :url => confirmation_path(resource_name) do |f| %>
+  <%= f.error_messages %>
+
+  <p><%= f.label :email %></p>
+  <p><%= f.text_field :email %></p>
+
+  <p><%= f.submit "Resend confirmation instructions" %></p>
+<% end %>
+
+<%= link_to "Sign in", new_session_path(resource_name) %><br />
+
+<%- if devise_mapping.recoverable? %>
+  <%= link_to "Forgot password?", new_password_path(resource_name) %><br />
+<% end -%>

data/app/views/notifier/confirmation_instructions.html.erb

@@ -0,0 +1,5 @@
+Welcome <%= @resource.email %>!
+
+You can confirm your account through the link below:
+
+<%= link_to 'Confirm my account', confirmation_url(@resource, :confirmation_token => @resource.confirmation_token) %>

data/app/views/notifier/reset_password_instructions.html.erb

@@ -0,0 +1,8 @@
+Hello <%= @resource.email %>!
+
+Someone has requested a link to change your password, and you can do this through the link below.
+
+<%= link_to 'Change my password', edit_password_url(@resource, :reset_password_token => @resource.reset_password_token) %>
+
+If you didn't request this, please ignore this email.
+Your password won't change until you access the link above and create a new one.

data/app/views/passwords/edit.html.erb

@@ -0,0 +1,20 @@
+<h2>Change your password</h2>
+
+<% form_for resource_name, :url => password_path(resource_name), :html => { :method => :put } do |f| %>
+  <%= f.error_messages %>
+  <%= f.hidden_field :reset_password_token %>
+
+  <p><%= f.label :password %></p>
+  <p><%= f.password_field :password %></p>
+
+  <p><%= f.label :password_confirmation %></p>
+  <p><%= f.password_field :password_confirmation %></p>
+
+  <p><%= f.submit "Change my password" %></p>
+<% end %>
+
+<%= link_to "Sign in", new_session_path(resource_name) %><br />
+
+<%- if devise_mapping.confirmable? %>
+  <%= link_to "Didn't receive confirmation instructions?", new_confirmation_path(resource_name) %><br />
+<% end -%>

data/app/views/passwords/new.html.erb

@@ -0,0 +1,16 @@
+<h2>Forgot your password?</h2>
+
+<% form_for resource_name, :url => password_path(resource_name) do |f| %>
+  <%= f.error_messages %>
+
+  <p><%= f.label :email %></p>
+  <p><%= f.text_field :email %></p>
+
+  <p><%= f.submit "Send me reset password instructions" %></p>
+<% end %>
+
+<%= link_to "Sign in", new_session_path(resource_name) %><br />
+
+<%- if devise_mapping.confirmable? %>
+  <%= link_to "Didn't receive confirmation instructions?", new_confirmation_path(resource_name) %><br />
+<% end -%>

data/app/views/sessions/new.html.erb

@@ -0,0 +1,23 @@
+<h2>Sign in</h2>
+
+<% form_for resource_name, :url => session_path(resource_name) do |f| -%>
+  <p><%= f.label :email %></p>
+  <p><%= f.text_field :email %></p>
+
+  <p><%= f.label :password %></p>
+  <p><%= f.password_field :password %></p>
+
+  <% if devise_mapping.rememberable? -%>
+    <p><%= f.check_box :remember_me %> <%= f.label :remember_me %></p>
+  <% end -%>
+
+  <p><%= f.submit "Sign in" %></p>
+<% end -%>
+
+<%- if devise_mapping.recoverable? %>
+  <%= link_to "Forgot password?", new_password_path(resource_name) %><br />
+<% end -%>
+
+<%- if devise_mapping.confirmable? %>
+  <%= link_to "Didn't receive confirmation instructions?", new_confirmation_path(resource_name) %><br />
+<% end -%>

data/config/locales/en.yml

@@ -0,0 +1,16 @@
+en:
+  devise:
+    sessions:
+      signed_in: 'Signed in successfully.'
+      signed_out: 'Signed out successfully.'
+      unauthenticated: '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.'
+    notifier:
+      confirmation_instructions: 'Confirmation instructions'
+      reset_password_instructions: 'Reset password instructions'
+

data/init.rb

@@ -0,0 +1,2 @@
+# We need to load devise here to ensure routes extensions are loaded.
+require 'devise'

data/lib/devise.rb

@@ -0,0 +1,48 @@
+module Devise
+  ALL = [:authenticable, :confirmable, :recoverable, :rememberable, :validatable].freeze
+
+  # Maps controller names to devise modules
+  CONTROLLERS = {
+    :sessions => :authenticable,
+    :passwords => :recoverable,
+    :confirmations => :confirmable
+  }.freeze
+
+  TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].freeze
+
+  MODEL_CONFIG = []
+
+  def self.model_config(klass, accessor, default=nil)
+    # Create Devise accessor
+    mattr_accessor accessor
+
+    # Set default value
+    send(:"#{accessor}=", default)
+
+    # Store configuration method
+    MODEL_CONFIG << accessor
+
+    # Set default value
+    klass.class_eval <<-METHOD
+      def #{accessor}
+        Devise.#{accessor}
+      end
+    METHOD
+  end
+end
+
+# Devise initialization process goes like this:
+#
+#   1) Include Devise::ActiveRecord and Devise::Migrations
+#   2) Load and config warden
+#   3) Add routes extensions
+#   4) Load routes definitions
+#   5) Include filters and helpers in controllers and views
+#
+Rails.configuration.after_initialize do
+  ActiveRecord::Base.extend Devise::ActiveRecord
+  ActiveRecord::ConnectionAdapters::TableDefinition.send :include, Devise::Migrations
+end
+
+require 'devise/warden'
+require 'devise/routes'

data/lib/devise/active_record.rb

@@ -0,0 +1,86 @@
+module Devise
+  module ActiveRecord
+    # Shortcut method for including all devise modules inside your model.
+    # You can give some extra options while declaring devise in your model:
+    #
+    # * except: convenient option that allows you to add all devise modules,
+    #   removing only the modules you setup here:
+    #
+    #    devise :all, :except => :rememberable
+    #
+    # * pepper: setup a pepper to generate de encrypted password. By default no
+    #   pepper is used:
+    #
+    #    devise :all, :pepper => 'my_pepper'
+    #
+    # * stretches: configure how many times you want the password is reencrypted.
+    #
+    #    devise :all, :stretches => 20
+    #
+    # You can refer to Authenticable for more information about writing your own
+    # method to setup pepper and stretches.
+    #
+    # Examples:
+    #
+    #   # include only authenticable module (default)
+    #   devise
+    #
+    #   # include authenticable + confirmable modules
+    #   devise :confirmable
+    #
+    #   # include authenticable + recoverable modules
+    #   devise :recoverable
+    #
+    #   # include authenticable + rememberable modules
+    #   devise :rememberable
+    #
+    #   # include authenticable + validatable modules
+    #   devise :validatable
+    #
+    #   # include authenticable + confirmable + recoverable + rememberable + validatable
+    #   devise :confirmable, :recoverable, :rememberable, :validatable
+    #
+    #   # shortcut to include all modules (same as above)
+    #   devise :all
+    #
+    #   # include all except recoverable
+    #   devise :all, :except => :recoverable
+    #
+    def devise(*modules)
+      options  = modules.extract_options!
+      options.assert_valid_keys(:except, *Devise::MODEL_CONFIG)
+
+      modules  = Devise::ALL                    if modules.include?(:all)
+      modules -= Array(options.delete(:except)) if options.key?(:except)
+      modules |= [:authenticable]
+
+      modules.each do |m|
+        devise_modules << m.to_sym
+        include Devise::Models.const_get(m.to_s.classify)
+      end
+
+      # Convert new keys to methods which overwrites Devise defaults
+      options.each do |key, value|
+        case value
+          when Proc
+            define_method key, &value
+            next
+          when ActiveSupport::Duration
+            value = value.to_i
+        end
+
+        class_eval <<-END_EVAL, __FILE__, __LINE__
+          def #{key}
+            #{value.inspect}
+          end
+        END_EVAL
+      end
+    end
+
+    # Stores all modules included inside the model, so we are able to verify
+    # which routes are needed.
+    def devise_modules
+      @devise_modules ||= []
+    end
+  end
+end

data/lib/devise/controllers/filters.rb

@@ -0,0 +1,109 @@
+module Devise
+  module Controllers
+    module Filters
+
+      def self.included(base)
+        base.class_eval do
+          helper_method :warden, :signed_in?,
+                        *Devise.mappings.keys.map { |m| [:"current_#{m}", :"#{m}_signed_in?"] }.flatten
+        end
+      end
+
+      # The main accessor for the warden proxy instance
+      def warden
+        request.env['warden']
+      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 => :authenticable
+      #     Admin => :authenticable
+      #
+      #   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
+
+    protected
+
+      # 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 root_path if warden.authenticated?(resource_name)
+      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
+
+    end
+  end
+end

data/lib/devise/controllers/helpers.rb

@@ -0,0 +1,91 @@
+module Devise
+  module Controllers
+    module Helpers
+
+      def self.included(base)
+        base.class_eval do
+          helper_method :resource, :resource_name, :resource_class, :devise_mapping
+        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
+
+    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
+
+      # Attempt to find the mapped route for devise based on request path
+      def devise_mapping
+        @devise_mapping ||= Devise.find_mapping_by_path(request.path)
+      end
+
+      # Sets the resource creating an instance variable
+      def resource=(new_resource)
+        instance_variable_set(:"@#{resource_name}", new_resource)
+      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)
+        flash[key] = I18n.t(:"#{resource_name}.#{kind}",
+                            :scope => [:devise, controller_name.to_sym], :default => kind)
+      end
+
+    end
+  end
+end