shingara-devise 0.4.3

data/lib/devise/models/rememberable.rb

@@ -0,0 +1,95 @@
+require 'digest/sha1'
+require 'devise/hooks/rememberable'
+require 'devise/strategies/rememberable'
+
+module Devise
+  module Models
+
+    # Rememberable manages generating and clearing token for remember the user
+    # from a saved cookie. Rememberable also has utility methods for dealing
+    # with serializing the user into the cookie and back from the cookie, trying
+    # to lookup the record based on the saved information.
+    # You probably wouldn't use rememberable methods directly, they are used
+    # mostly internally for handling the remember token.
+    #
+    # Configuration:
+    #
+    #   remember_for: the time you want the user will be remembered without
+    #                 asking for credentials. After this time the user will be
+    #                 blocked and will have to enter his credentials again.
+    #                 This configuration is also used to calculate the expires
+    #                 time for the cookie created to remember the user.
+    #                 By default remember_for is 2.weeks.
+    #
+    # Examples:
+    #
+    #   User.find(1).remember_me!  # regenerating the token
+    #   User.find(1).forget_me!    # clearing the token
+    #
+    #   # generating info to put into cookies
+    #   User.serialize_into_cookie(user)
+    #
+    #   # lookup the user based on the incoming cookie information
+    #   User.serialize_from_cookie(cookie_string)
+    module Rememberable
+
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+
+          # Remember me option available in after_authentication hook.
+          attr_accessor :remember_me
+        end
+      end
+
+      # Generate a new remember token and save the record without validations.
+      def remember_me!
+        self.remember_token = friendly_token
+        self.remember_created_at = Time.now.utc
+        save(false)
+      end
+
+      # Removes the remember token only if it exists, and save the record
+      # without validations.
+      def forget_me!
+        if remember_token?
+          self.remember_token = nil
+          self.remember_created_at = nil
+          save(false)
+        end
+      end
+
+      # Checks whether the incoming token matches or not with the record token.
+      def valid_remember_token?(token)
+        remember_token? && !remember_expired? && remember_token == token
+      end
+
+      # Remember token should be expired if expiration time not overpass now.
+      def remember_expired?
+        remember_expires_at <= Time.now.utc
+      end
+
+      # Remember token expires at created time + remember_for configuration
+      def remember_expires_at
+        remember_created_at + remember_for
+      end
+
+      module ClassMethods
+
+        # Create the cookie key using the record id and remember_token
+        def serialize_into_cookie(rememberable)
+          "#{rememberable.id}::#{rememberable.remember_token}"
+        end
+
+        # Recreate the user based on the stored cookie
+        def serialize_from_cookie(cookie)
+          rememberable_id, remember_token = cookie.split('::')
+          rememberable = find_by_id(rememberable_id) if rememberable_id
+          rememberable if rememberable.try(:valid_remember_token?, remember_token)
+        end
+      end
+
+      Devise::Models.config(self, :remember_for)
+    end
+  end
+end

data/lib/devise/models/validatable.rb

@@ -0,0 +1,36 @@
+module Devise
+  module Models
+
+    # Validatable creates all needed validations for a user email and password.
+    # It's optional, given you may want to create the validations by yourself.
+    # Automatically validate if the email is present, unique and it's format is
+    # valid. Also tests presence of password, confirmation and length
+    module Validatable
+
+      # Email regex used to validate email formats. Retrieved from authlogic.
+      EMAIL_REGEX = /\A[\w\.%\+\-]+@(?:[A-Z0-9\-]+\.)+(?:[A-Z]{2,4}|museum|travel)\z/i
+
+      def self.included(base)
+        base.class_eval do
+
+          validates_presence_of     :email
+          validates_uniqueness_of   :email, :allow_blank => true
+          validates_format_of       :email, :with => EMAIL_REGEX, :allow_blank => true
+
+          validates_presence_of     :password, :if => :password_required?
+          validates_confirmation_of :password, :if => :password_required?
+          validates_length_of       :password, :within => 6..20, :allow_blank => true, :if => :password_required?
+        end
+      end
+
+      protected
+
+        # Checks whether a password is needed or not. For validations only.
+        # Passwords are always required if it's a new record, or if the password
+        # or confirmation are being set somewhere.
+        def password_required?
+          new_record? || !password.nil? || !password_confirmation.nil?
+        end
+    end
+  end
+end

data/lib/devise/models.rb

@@ -0,0 +1,110 @@
+module Devise
+  module Models
+    # Creates configuration values for Devise and for the given module.
+    #
+    #   Devise::Models.config(Devise::Authenticable, :stretches, 10)
+    #
+    # The line above creates:
+    #
+    #   1) An accessor called Devise.stretches, which value is used by default;
+    #
+    #   2) Some class methods for your model Model.stretches and Model.stretches=
+    #      which have higher priority than Devise.stretches;
+    #
+    #   3) And an instance method stretches.
+    #
+    # To add the class methods you need to have a module ClassMethods defined
+    # inside the given class.
+    #
+    def self.config(mod, accessor) #:nodoc:
+      mod.class_eval <<-METHOD, __FILE__, __LINE__
+        def #{accessor}
+          self.class.#{accessor}
+        end
+      METHOD
+
+      mod.const_get(:ClassMethods).class_eval <<-METHOD, __FILE__, __LINE__
+        def #{accessor}
+          if defined?(@#{accessor})
+            @#{accessor}
+          elsif superclass.respond_to?(:#{accessor})
+            superclass.#{accessor}
+          else
+            Devise.#{accessor}
+          end
+        end
+
+        def #{accessor}=(value)
+          @#{accessor} = value
+        end
+      METHOD
+    end
+
+    # 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
+    #
+    # You can also give the following configuration values in a hash: :pepper,
+    # :stretches, :confirm_within and :remember_for. Please check your Devise
+    # initialiazer for a complete description on those values.
+    #
+    # Examples:
+    #
+    #   # include only authenticatable module (default)
+    #   devise
+    #
+    #   # include authenticatable + confirmable modules
+    #   devise :confirmable
+    #
+    #   # include authenticatable + recoverable modules
+    #   devise :recoverable
+    #
+    #   # include authenticatable + rememberable modules
+    #   devise :rememberable
+    #
+    #   # include authenticatable + validatable modules
+    #   devise :validatable
+    #
+    #   # include authenticatable + 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!
+
+      modules  = Devise::ALL if modules.include?(:all)
+      modules -= Array(options.delete(:except))
+      modules  = [:authenticatable] | modules
+
+      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 { |key, value| send(:"#{key}=", value) }
+
+      if Devise.orm == 'MongoMapper'
+        modules.each do |mod|
+          send(mod)
+        end
+      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/orm/mongo_mapper.rb

@@ -0,0 +1,26 @@
+module Devise
+  module Orm
+    module MongoMapper
+      def authenticatable
+        key :email, String
+        key :encrypted_password, String
+        key :password_salt, String
+      end
+
+      def confirmable
+        key :confirmation_token, String
+        key :confirmed_at, DateTime
+        key :confirmation_sent_at, DateTime
+      end
+
+      def recoverable
+        key :reset_password_token, String
+      end
+
+      def rememberable
+        key :remember_token, String
+        key :remember_created_at, DateTime
+      end
+    end
+  end
+end

data/lib/devise/rails/routes.rb

@@ -0,0 +1,109 @@
+module ActionController::Routing
+  class RouteSet #:nodoc:
+
+    # Ensure Devise modules are included only after loading routes, because we
+    # need devise_for mappings already declared to create magic filters and
+    # helpers.
+    def load_routes_with_devise!
+      load_routes_without_devise!
+
+      ActionController::Base.send :include, Devise::Controllers::Filters
+      ActionController::Base.send :include, Devise::Controllers::UrlHelpers
+
+      ActionView::Base.send :include, Devise::Controllers::UrlHelpers
+    end
+    alias_method_chain :load_routes!, :devise
+
+    class Mapper #:doc:
+      # Includes devise_for method for routes. This method is responsible to
+      # generate all needed routes for devise, based on what modules you have
+      # defined in your model.
+      # Examples: Let's say you have an User model configured to use
+      # authenticatable, confirmable and recoverable modules. After creating this
+      # inside your routes:
+      #
+      #   map.devise_for :users
+      #
+      # this method is going to look inside your User model and create the
+      # needed routes:
+      #
+      #  # Session routes for Authenticatable (default)
+      #       new_user_session GET  /users/sign_in                    {:controller=>"sessions", :action=>"new"}
+      #           user_session POST /users/sign_in                    {:controller=>"sessions", :action=>"create"}
+      #   destroy_user_session GET  /users/sign_out                   {:controller=>"sessions", :action=>"destroy"}
+      #
+      #  # Password routes for Recoverable, if User model has :recoverable configured
+      #      new_user_password GET  /users/password/new(.:format)     {:controller=>"passwords", :action=>"new"}
+      #     edit_user_password GET  /users/password/edit(.:format)    {:controller=>"passwords", :action=>"edit"}
+      #          user_password PUT  /users/password(.:format)         {:controller=>"passwords", :action=>"update"}
+      #                        POST /users/password(.:format)         {:controller=>"passwords", :action=>"create"}
+      #
+      #  # Confirmation routes for Confirmable, if User model has :confirmable configured
+      #  new_user_confirmation GET  /users/confirmation/new(.:format) {:controller=>"confirmations", :action=>"new"}
+      #      user_confirmation GET  /users/confirmation(.:format)     {:controller=>"confirmations", :action=>"show"}
+      #                        POST /users/confirmation(.:format)     {:controller=>"confirmations", :action=>"create"}
+      #
+      # You can configure your routes with some options:
+      #  * :class_name => setup a different class to be looked up by devise, if it cannot be correctly find by the route name.
+      #
+      #    map.devise_for :users, :class_name => 'Account'
+      #
+      #  * :as => allows you to setup path name that will be used, as rails routes does. The following route configuration would setup your route as /accounts instead of /users:
+      #
+      #    map.devise_for :users, :as => 'accounts'
+      #
+      #  * :singular => setup the name used to create named routes. By default, for a :users key, it is going to be the singularized version, :user. To configure a named route like account_session_path instead of user_session_path just do:
+      #
+      #    map.devise_for :users, :singular => :account
+      #
+      #  * :path_names => configure different path names to overwrite defaults :sign_in, :sign_out, :password and :confirmation.
+      #
+      #    map.devise_for :users, :path_names => { :sign_in => 'login', :sign_out => 'logout', :password => 'secret', :confirmation => 'verification' }
+      #
+      #  * :path_prefix => the path prefix to be used in all routes.
+      #
+      #    map.devise_for :users, :path_prefix => "/:locale"
+      #
+      #  If you are using a dynamic prefix, like :locale above, you need to configure default_url_options through Devise. You can do that in config/initializers/devise.rb or setting a Devise.default_url_options:
+      #
+      #    Devise.default_url_options do
+      #      { :locale => I18n.locale }
+      #    end
+      #
+      def devise_for(*resources)
+        options = resources.extract_options!
+
+        resources.map!(&:to_sym)
+        resources.each do |resource|
+          mapping = Devise::Mapping.new(resource, options)
+          Devise.mappings[mapping.name] = mapping
+
+          with_options(:path_prefix => mapping.raw_path, :name_prefix => "#{mapping.name}_") do |routes|
+            mapping.for.each do |strategy|
+              send(strategy, routes, mapping) if self.respond_to?(strategy, true)
+            end
+          end
+        end
+      end
+
+      protected
+
+        def authenticatable(routes, mapping)
+          routes.with_options(:controller => 'sessions', :name_prefix => nil) do |session|
+            session.send(:"new_#{mapping.name}_session",     mapping.path_names[:sign_in],  :action => 'new',     :conditions => { :method => :get })
+            session.send(:"#{mapping.name}_session",         mapping.path_names[:sign_in],  :action => 'create',  :conditions => { :method => :post })
+            session.send(:"destroy_#{mapping.name}_session", mapping.path_names[:sign_out], :action => 'destroy', :conditions => { :method => :get })
+          end
+        end
+
+        def recoverable(routes, mapping)
+          routes.resource :password, :only => [:new, :create, :edit, :update], :as => mapping.path_names[:password]
+        end
+
+        def confirmable(routes, mapping)
+          routes.resource :confirmation, :only => [:new, :create, :show], :as => mapping.path_names[:confirmation]
+        end
+
+    end
+  end
+end

data/lib/devise/rails/warden_compat.rb

@@ -0,0 +1,26 @@
+# Taken from RailsWarden, thanks to Hassox. http://github.com/hassox/rails_warden
+module Warden::Mixins::Common
+  # Gets the rails request object by default if it's available
+  def request
+    return @request if @request
+    if env['action_controller.rescue.request']
+      @request = env['action_controller.rescue.request']
+    else
+      Rack::Request.new(env)
+    end
+  end
+
+  def raw_session
+    request.session
+  end
+
+  def reset_session!
+    raw_session.inspect # why do I have to inspect it to get it to clear?
+    raw_session.clear
+  end
+
+  # Proxy to request cookies
+  def cookies
+    request.cookies
+  end
+end

data/lib/devise/rails.rb

@@ -0,0 +1,17 @@
+require 'devise/rails/routes'
+require 'devise/rails/warden_compat'
+
+Rails.configuration.after_initialize do
+  if defined?(ActiveRecord)
+    ActiveRecord::Base.extend Devise::Models
+    ActiveRecord::ConnectionAdapters::TableDefinition.send :include, Devise::Migrations
+  end
+
+  # Adds Warden Manager to Rails middleware stack, configuring default devise
+  # strategy and also the failure app.
+  Rails.configuration.middleware.use Warden::Manager do |manager|
+    Devise.configure_warden_manager(manager)
+  end
+
+  I18n.load_path.unshift File.expand_path(File.join(File.dirname(__FILE__), 'locales', 'en.yml'))
+end

data/lib/devise/strategies/authenticatable.rb

@@ -0,0 +1,46 @@
+module Devise
+  module Strategies
+    # Default strategy for signing in a user, based on his email and password.
+    # Redirects to sign_in page if it's not authenticated
+    class Authenticatable < Devise::Strategies::Base
+
+      # Authenticate a user based on email and password params, returning to warden
+      # success and the authenticated user if everything is okay. Otherwise redirect
+      # to sign in page.
+      #
+      # Please notice the semantic difference between calling fail! and throw :warden.
+      # The first does not perform any action when calling authenticate, just
+      # when authenticate! is invoked. The second always perform the action.
+      def authenticate!
+        if valid_attributes? && resource = mapping.to.authenticate(attributes)
+          success!(resource)
+        else
+          store_location
+          fail!(:unauthenticated)
+        end
+      end
+
+      private
+
+        # Find the attributes for the current mapping.
+        def attributes
+          @attributes ||= params[scope]
+        end
+
+        # Check for the right keys.
+        def valid_attributes?
+          attributes && attributes[:email].present? && attributes[:password].present?
+        end
+
+        # Stores requested uri to redirect the user after signing in. We cannot use
+        # scoped session provided by warden here, since the user is not authenticated
+        # yet, but we still need to store the uri based on scope, so different scopes
+        # would never use the same uri to redirect.
+        def store_location
+          session[:"#{mapping.name}.return_to"] = request.request_uri if request.get?
+        end
+    end
+  end
+end
+
+Warden::Strategies.add(:authenticatable, Devise::Strategies::Authenticatable)

data/lib/devise/strategies/base.rb

@@ -0,0 +1,24 @@
+module Devise
+  module Strategies
+    # Base strategy for Devise. Responsible for verifying correct scope and
+    # mapping.
+    class Base < Warden::Strategies::Base
+
+      # Validate strategy. By default will raise an error if no scope or an
+      # invalid mapping is found.
+      def valid?
+        mapping.for.include?(self.class.name.split("::").last.underscore.to_sym)
+      end
+
+      # Checks if a valid scope was given for devise and find mapping based on
+      # this scope.
+      def mapping
+        @mapping ||= begin
+          raise "You need to give a scope for Devise authentication" unless scope
+          raise "You need to give a valid Devise mapping"            unless mapping = Devise.mappings[scope]
+          mapping
+        end
+      end
+    end
+  end
+end

data/lib/devise/strategies/rememberable.rb

@@ -0,0 +1,35 @@
+module Devise
+  module Strategies
+    # Remember the user through the remember token. This strategy is responsible
+    # to verify whether there is a cookie with the remember token, and to
+    # recreate the user from this cookie if it exists.  Must be called *before*
+    # authenticatable.
+    class Rememberable < Devise::Strategies::Base
+
+      # A valid strategy for rememberable needs a remember token in the cookies.
+      def valid?
+        super && remember_me_cookie.present?
+      end
+
+      # To authenticate a user we deserialize the cookie and attempt finding
+      # the record in the database. If the attempt fails, we pass to another
+      # strategy handle the authentication.
+      def authenticate!
+        if resource = mapping.to.serialize_from_cookie(remember_me_cookie)
+          success!(resource)
+        else
+          pass
+        end
+      end
+
+      private
+
+        # Accessor for remember cookie
+        def remember_me_cookie
+          cookies['remember_token']
+        end
+    end
+  end
+end
+
+Warden::Strategies.add(:rememberable, Devise::Strategies::Rememberable)

data/lib/devise/version.rb

@@ -0,0 +1,3 @@
+module Devise
+  VERSION = "0.4.3".freeze
+end

data/lib/devise/warden.rb

@@ -0,0 +1,20 @@
+begin
+  require 'warden'
+rescue
+  gem 'warden'
+  require 'warden'
+end
+
+# Session Serialization in. This block determines how the user will be stored
+# in the session. If you're using a complex object like an ActiveRecord model,
+# it is not a good idea to store the complete object. An ID is sufficient.
+Warden::Manager.serialize_into_session{ |user| [user.class, user.id] }
+
+# Session Serialization out. This block gets the user out of the session.
+# It should be the reverse of serializing the object into the session
+Warden::Manager.serialize_from_session do |klass, id|
+  klass.find_by_id(id)
+end
+
+# Setup devise strategies for Warden
+require 'devise/strategies/base'

data/lib/devise.rb

@@ -0,0 +1,130 @@
+module Devise
+  ALL = [:authenticatable, :confirmable, :recoverable, :rememberable, :validatable].freeze
+
+  # Maps controller names to devise modules
+  CONTROLLERS = {
+    :sessions => :authenticatable,
+    :passwords => :recoverable,
+    :confirmations => :confirmable
+  }.freeze
+
+  STRATEGIES  = [:rememberable, :authenticatable].freeze
+  TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].freeze
+
+  # Maps the messages types that comes from warden to a flash type.
+  # This hash is not frozen, so you can add your messages as well.
+  FLASH_MESSAGES = {
+    :unauthenticated => :success,
+    :unconfirmed => :failure
+  }
+
+  # Declare encryptors length which are used in migrations.
+  ENCRYPTORS_LENGTH = {
+    :sha1   => 40,
+    :sha512 => 128,
+    :clearance_sha1 => 40,
+    :restful_authentication_sha1 => 40,
+    :authlogic_sha512 => 128
+  }
+
+  # Used to encrypt password. Please generate one with rake secret
+  mattr_accessor :pepper
+  @@pepper = nil
+
+  # The number of times to encrypt password.
+  mattr_accessor :stretches
+  @@stretches = 10
+
+  # Time interval where the remember me token is valid.
+  mattr_accessor :remember_for
+  @@remember_for = 2.weeks
+
+  # Time interval you can access your account before confirming your account.
+  mattr_accessor :confirm_within
+  @@confirm_within = 0.days
+
+  # Used to define the password encryption algorithm.
+  def self.encryptor=(value)
+    @@encryptor = if value.is_a?(Symbol)
+      ::Devise::Encryptors.const_get(value.to_s.classify)
+    else
+      value
+    end
+  end
+  mattr_reader :encryptor
+  @@encryptor = ::Devise::Encryptors::Sha1
+
+  # Store scopes mappings.
+  mattr_accessor :mappings
+  @@mappings = {}
+
+  @@orm = 'active_record'
+
+  # ORM choice
+  def self.orm()
+    @@orm
+  end
+
+  def self.orm=(type_orm)
+    if type_orm == 'MongoMapper'
+      MongoMapper::Document::ClassMethods.send(:include, Devise::Models)
+      require 'devise/orm/mongo_mapper'
+      MongoMapper::Document::ClassMethods.send(:include, Devise::Orm::MongoMapper)
+    end
+    @@orm = type_orm
+  end
+
+
+  class << self
+    # Default way to setup Devise. Run script/generate devise_install to create
+    # a fresh initializer with all configuration values.
+    def setup
+      yield self
+    end
+
+    def mail_sender=(value) #:nodoc:
+      ActiveSupport::Deprecation.warn "Devise.mail_sender= is deprecated, use Devise.mailer_sender instead"
+      DeviseMailer.sender = value
+    end
+
+    # Sets the sender in DeviseMailer.
+    def mailer_sender=(value)
+      DeviseMailer.sender = value
+    end
+    alias :sender= :mailer_sender=
+
+    # Sets warden configuration using a block that will be invoked on warden
+    # initialization.
+    #
+    #  Devise.initialize do |config|
+    #    config.confirm_within = 2.days
+    #
+    #    config.warden do |manager|
+    #      # Configure warden to use other strategies, like oauth.
+    #      manager.oauth(:twitter)
+    #    end
+    #  end
+    def warden(&block)
+      @warden_config = block
+    end
+
+    # Configure default url options to be used within Devise and ActionController.
+    def default_url_options(&block)
+      Devise::Mapping.metaclass.send :define_method, :default_url_options, &block
+    end
+
+    # A method used internally to setup warden manager from the Rails initialize
+    # block.
+    def configure_warden_manager(manager) #:nodoc:
+      manager.default_strategies *Devise::STRATEGIES
+      manager.failure_app = Devise::Failure
+      manager.silence_missing_strategies!
+
+      # If the user provided a warden hook, call it now.
+      @warden_config.try :call, manager
+    end
+  end
+end
+
+require 'devise/warden'
+require 'devise/rails'