revise 0.0.1

data/lib/revise/helpers/core.rb

@@ -0,0 +1,48 @@
+module Revise
+  module Helpers
+    module Core
+      def revise_for(*resources)
+        Revise.app = self
+
+        options = resources.extract_options!
+
+        resources.each do |resource|
+          begin
+            if Revise::MODULES.has_key?(resource)
+              models = Revise::MODULES[resource]
+              models.each do |m|
+                model = Revise::Models.const_get(m)
+                add_helpers(model)
+                add_controllers(model)
+                add_mailers(model)
+              end
+            else
+              Padrino.logger.error "Hey man #{resource} doesn't exist"
+            end
+          rescue Exception => e
+            Padrino.logger.error "Failed to load: #{resource} Because #{e.message()}"
+          end
+        end
+      end
+
+      private
+        def add_helpers(model)
+          model::HELPERS.each do |helper|
+            self.helpers(Revise::Helpers.const_get(helper))
+          end
+        end
+
+        def add_controllers(model)
+           model::CONTROLLERS.each do |controller|
+            self.send(:extend, Revise::Controllers.const_get(controller))
+          end
+        end
+
+        def add_mailers(model)
+          model::MAILERS.each do |mailer|
+            self.send(:extend, Revise::Mailers.const_get(mailer))
+          end
+        end
+    end
+  end
+end

data/lib/revise/inviter.rb

@@ -0,0 +1,40 @@
+module Revise
+  module Inviter
+    extend ActiveSupport::Concern
+
+    included do
+      extend ClassMethods
+      attr_writer :invitation_limit unless respond_to? :invitation_limit
+    end
+
+    def invitation_limit
+      self[:invitation_limit] || self.class.invitation_limit
+    end
+
+    # Return true if this user has invitations left to send
+    def has_invitations_left?
+      if self.class.invitation_limit.present? || self.respond_to?(:invitation_limit)
+        if invitation_limit
+          return invitation_limit > 0
+        else
+          return self.class.invitation_limit > 0 if self.class.invitation_limit.present?
+          return false
+        end
+      else
+        return true
+      end
+    end
+
+    protected
+      def decrement_invitation_limit!
+        if self.class.invitation_limit.present?
+          self.invitation_limit ||= self.class.invitation_limit
+          self.update_attribute(:invitation_limit, invitation_limit - 1)
+        end
+      end
+
+    module ClassMethods
+      Revise::Models.config(self, :invitation_limit)
+    end
+  end
+end

data/lib/revise/locale/en.yml

@@ -0,0 +1,11 @@
+en: 
+  revise:
+    recoverable:
+      reset_password_instructions:
+        subject: "Reset Password Instructions For %{domain}"
+    confirmable:
+      confirmation_instructions:
+        subject: "Confirm Your Email At %{domain}"
+    invitable:
+      invation_instructions:
+        subject: "You've Been Invited To %{domain}"

data/lib/revise/mailers/confirmable.rb

@@ -0,0 +1,18 @@
+module Revise
+  module Mailers
+    module Confirmable
+      def self.extended(klass)
+        klass.mailer :confirmable do 
+          email :confirmation_instructions do |name, email, confirmation_token|
+            from Revise.mailer_from
+            to email
+            subject t('revise.confirmable.confirmation_instructions.subject', :domain => ENV['DOMAIN'])
+            locals :name => name, :email => email, :confirmation_token => confirmation_token
+            render 'revise/confirmation_instructions'
+            content_type :html 
+          end
+        end
+      end
+    end
+  end
+end

data/lib/revise/mailers/invitable.rb

@@ -0,0 +1,18 @@
+module Revise
+  module Mailers
+    module Invitable
+      def self.extended(klass)
+        klass.mailer :invitable do 
+          email :invitation_instructions do |name, email, invitation_token|
+            from Revise.mailer_from
+            to email
+            subject t('revise.invitable.invitation_instructions.subject', :domain => ENV['DOMAIN'])
+            locals :name => name, :email => email, :invitation_token => invitation_token
+            render 'revise/invitation_instructions'
+            content_type :html 
+          end
+        end
+      end
+    end
+  end
+end

data/lib/revise/mailers/recoverable.rb

@@ -0,0 +1,18 @@
+module Revise
+  module Mailers
+    module Recoverable
+      def self.extended(klass)
+        klass.mailer :recoverable do 
+          email :reset_password_instructions do |name, email, reset_password_token|
+            from Revise.mailer_from
+            to email
+            subject t('revise.recoverable.reset_password_instructions.subject', :domain => ENV['DOMAIN'])
+            locals :name => name, :email => email, :reset_password_token => reset_password_token
+            render 'revise/reset_password_instructions'
+            content_type :html 
+          end
+        end
+      end
+    end
+  end
+end

data/lib/revise/models.rb

@@ -0,0 +1,99 @@
+module Revise
+  module Models
+    class MissingAttribute < StandardError
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def message
+        "The following attribute(s) is (are) missing on your model: #{@attributes.join(", ")}"
+      end
+    end
+
+    def self.config(mod, *accessors)
+      class << mod; attr_accessor :available_configs; end
+      mod.available_configs = accessors
+
+      accessors.each do |accessor|
+        mod.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+          def #{accessor}
+            if defined?(@#{accessor})
+              @#{accessor}
+            elsif superclass.respond_to?(:#{accessor})
+              superclass.#{accessor}
+            else
+              Revise.#{accessor}
+            end
+          end
+
+          def #{accessor}=(value)
+            @#{accessor} = value
+          end
+        METHOD
+      end
+    end
+
+    def self.check_fields!(klass)
+      failed_attributes = []
+      instance = klass.new
+
+      klass.revise_modules.each do |mod|
+        constant = const_get(mod.to_s.classify)
+
+        if constant.respond_to?(:required_fields)
+          constant.required_fields(klass).each do |field|
+            failed_attributes << field unless instance.respond_to?(field)
+          end
+        else
+          ActiveSupport::Deprecation.warn "The module #{mod} doesn't implement self.required_fields(klass). " \
+            "Devise uses required_fields to warn developers of any missing fields in their models. " \
+            "Please implement #{mod}.required_fields(klass) that returns an array of symbols with the required fields."
+        end
+      end
+
+      if failed_attributes.any?
+        fail Revise::Models::MissingAttribute.new(failed_attributes)
+      end
+    end
+    
+    def revise(*modules)
+      options = modules.extract_options!.dup
+
+      plural_name = self.model_name.plural.to_sym
+      Revise::MODULES[plural_name] = []
+
+      revise_modules_hook! do
+        include Revise::Models::Authenticatable
+
+        modules.each do |m|
+          mod = Revise::Models.const_get(m.to_s.classify)
+
+          if mod.const_defined?("ClassMethods")
+            class_mod = mod.const_get("ClassMethods")
+            extend class_mod
+
+            if class_mod.respond_to?(:available_configs)
+              available_configs = class_mod.available_configs
+              available_configs.each do |config|
+                next unless options.key?(config)
+                send(:"#{config}=", options.delete(config))
+              end
+            end
+          end
+
+          include mod
+
+          Revise::MODULES[plural_name] << m.to_s.classify
+        end
+
+        options.each { |key, value| send(:"#{key}=", value) }
+      end
+    end
+
+    def revise_modules_hook!
+      yield
+    end
+  end
+end
+
+require 'revise/models/authenticatable'

data/lib/revise/models/authenticatable.rb

@@ -0,0 +1,137 @@
+module Revise
+  module Models
+    module Authenticatable
+      extend ActiveSupport::Concern
+
+      MAILERS     = []
+      HELPERS     = ['Authentication']
+      CONTROLLERS = ['Main', 'Sessions', 'Accounts']
+
+      BLACKLIST_FOR_SERIALIZATION = [:encrypted_password, :reset_password_token, :reset_password_sent_at, :role,
+        :remember_created_at, :sign_in_count, :current_sign_in_at, :last_sign_in_at, :current_sign_in_ip,
+        :last_sign_in_ip, :password_salt, :confirmation_token, :confirmed_at, :confirmation_sent_at,
+        :remember_token, :unconfirmed_email, :failed_attempts, :unlock_token, :locked_at, :authentication_token, :role, 
+        :roles]
+
+      included do
+        before_validation :downcase_keys
+        before_validation :strip_whitespace
+        attr_accessor :skip_email
+      end
+
+      def self.required_fields(klass)
+        [:role]
+      end
+
+      def valid_for_authentication?
+        block_given? ? yield : true
+      end
+
+      def unauthenticated_message
+        :invalid
+      end
+
+      def active_for_authentication?
+        true
+      end
+
+      def inactive_message
+        :inactive
+      end
+
+      def password_required?
+        encrypted_password.blank? || password.present?
+      end
+
+      def role?(role)
+        return false unless self.respond_to?(:role)
+        return self.role.to_sym == role.to_sym
+      end
+
+      array = %w(serializable_hash)
+      array << "to_xml"
+
+      array.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__
+          def #{method}(options=nil)
+            options ||= {}
+            options[:except] = Array(options[:except])
+
+            if options[:force_except]
+              options[:except].concat Array(options[:force_except])
+            else
+              options[:except].concat BLACKLIST_FOR_SERIALIZATION
+            end
+            super(options)
+          end
+        RUBY
+      end
+
+      protected
+
+      def send_revise_notification(resource, notification, *attributes)
+        return false if self.email.blank?
+        Revise.app.deliver(resource, notification, *attributes) unless @skip_email
+      end
+
+      def downcase_keys
+        self.class.case_insensitive_keys.each { |k| self[k].try(:downcase!) }
+      end
+
+      def strip_whitespace
+        self.class.strip_whitespace_keys.each { |k| self[k].try(:strip!) }
+      end
+
+      module ClassMethods
+        Revise::Models.config(self, :authentication_keys, :request_keys, :strip_whitespace_keys,
+          :case_insensitive_keys, :http_authenticatable, :params_authenticatable, :skip_session_storage)
+
+        def find_for_authentication(conditions)
+          find_first_by_auth_conditions(conditions)
+        end
+
+        def find_first_by_auth_conditions(conditions)
+          to_adapter.find_first revise_param_filter.filter(conditions)
+        end
+
+        def find_or_initialize_with_error_by(attribute, value, error=:invalid) #:nodoc:
+          find_or_initialize_with_errors([attribute], { attribute => value }, error)
+        end
+
+        # Find an initialize a group of attributes based on a list of required attributes.
+        def find_or_initialize_with_errors(required_attributes, attributes, error=:invalid) #:nodoc:
+          attributes = attributes.slice(*required_attributes)
+          attributes.delete_if { |key, value| value.blank? }
+
+          if attributes.size == required_attributes.size
+            record = find_first_by_auth_conditions(attributes)
+          end
+
+          unless record
+            record = new
+
+            required_attributes.each do |key|
+              value = attributes[key]
+              record.send("#{key}=", value)
+              record.errors.add(key, value.present? ? error : :blank)
+            end
+          end
+
+          record
+        end
+
+        protected
+          def revise_param_filter
+            @revise_param_filter ||= Revise::ParamFilter.new(case_insensitive_keys, strip_whitespace_keys)
+          end
+
+          def generate_token(column)
+            loop do
+              token = String.friendly_token
+              break token unless to_adapter.find_first({ column => token })
+            end
+          end
+      end
+    end
+  end
+end

data/lib/revise/models/confirmable.rb

@@ -0,0 +1,236 @@
+module Revise
+  module Models
+    module Confirmable
+      extend ActiveSupport::Concern
+
+      MAILERS     = ['Confirmable']
+      HELPERS     = []
+      CONTROLLERS = ['Confirmations']
+
+      included do
+        before_create :generate_confirmation_token,              :if => :confirmation_required?
+        after_create  :send_on_create_confirmation_instructions, :if => :confirmation_required?
+        before_update :postpone_email_change_until_confirmation, :if => :postpone_email_change?
+        after_update  :send_confirmation_instructions,           :if => :reconfirmation_required?
+      end
+
+      def self.required_fields(klass)
+        required_methods = [:confirmation_token, :confirmed_at, :confirmation_sent_at]
+        required_methods << :unconfirmed_email if klass.reconfirmable
+        required_methods
+      end
+
+      # Confirm a user by setting it's confirmed_at to actual time. If the user
+      # is already confirmed, add an error to email field. If the user is invalid
+      # add errors
+      def confirm!
+        pending_any_confirmation do
+          if confirmation_period_expired?
+            self.errors.add(:confirmation_period_expired, 'Token expired')
+            return false
+          end
+
+          self.confirmation_token = nil
+          self.confirmed_at = Time.now.utc
+
+          if self.class.reconfirmable && unconfirmed_email.present?
+            skip_reconfirmation!
+            self.email = unconfirmed_email
+            self.unconfirmed_email = nil
+
+            # We need to validate in such cases to enforce e-mail uniqueness
+            save(:validate => true)
+          else
+            save(:validate => false)
+          end
+        end
+      end
+
+      # Verifies whether a user is confirmed or not
+      def confirmed?
+        !!confirmed_at
+      end
+
+      def pending_reconfirmation?
+        self.class.reconfirmable && unconfirmed_email.present?
+      end
+
+      # Send confirmation instructions by email
+      def send_confirmation_instructions
+        self.confirmation_token  = nil if reconfirmation_required?
+        @reconfirmation_required = false
+
+        generate_confirmation_token! if self.confirmation_token.blank?
+        send_revise_notification(:confirmable, :confirmation_instructions, self.name, self.email, self.confirmation_token)
+      end
+
+      # Resend confirmation token. This method does not need to generate a new token.
+      def resend_confirmation_token
+        pending_any_confirmation do
+          self.confirmation_token = nil if confirmation_period_expired?
+          send_confirmation_instructions
+        end
+      end
+
+      # Overwrites active_for_authentication? for confirmation
+      # by verifying whether a user is active to sign in or not. If the user
+      # is already confirmed, it should never be blocked. Otherwise we need to
+      # calculate if the confirm time has not expired for this user.
+      def active_for_authentication?
+        super && (!confirmation_required? || confirmed? || confirmation_period_valid?)
+      end
+
+      # The message to be shown if the account is inactive.
+      def inactive_message
+        !confirmed? ? :unconfirmed : super
+      end
+
+      # If you don't want confirmation to be sent on create, neither a code
+      # to be generated, call skip_confirmation!
+      def skip_confirmation!
+        self.confirmed_at = Time.now.utc
+      end
+
+      # If you don't want reconfirmation to be sent, neither a code
+      # to be generated, call skip_reconfirmation!
+      def skip_reconfirmation!
+        @bypass_postpone = true
+      end
+
+      protected
+
+        # A callback method used to deliver confirmation
+        # instructions on creation. This can be overriden
+        # in models to map to a nice sign up e-mail.
+        def send_on_create_confirmation_instructions
+          send_revise_notification(:confirmable, :confirmation_instructions, self.name, self.email, self.confirmation_token)
+        end
+
+        # Callback to overwrite if confirmation is required or not.
+        def confirmation_required?
+          !confirmed?
+        end
+
+        # Checks if the confirmation for the user is within the limit time.
+        # We do this by calculating if the difference between today and the
+        # confirmation sent date does not exceed the confirm in time configured.
+        # Confirm_within is a model configuration, must always be an integer value.
+        #
+        # Example:
+        #
+        #   # allow_unconfirmed_access_for = 1.day and confirmation_sent_at = today
+        #   confirmation_period_valid?   # returns true
+        #
+        #   # allow_unconfirmed_access_for = 5.days and confirmation_sent_at = 4.days.ago
+        #   confirmation_period_valid?   # returns true
+        #
+        #   # allow_unconfirmed_access_for = 5.days and confirmation_sent_at = 5.days.ago
+        #   confirmation_period_valid?   # returns false
+        #
+        #   # allow_unconfirmed_access_for = 0.days
+        #   confirmation_period_valid?   # will always return false
+        #
+        def confirmation_period_valid?
+          confirmation_sent_at && confirmation_sent_at.utc >= self.class.allow_unconfirmed_access_for.ago
+        end
+
+        # Checks if the user confirmation happens before the token becomes invalid
+        # Examples:
+        #
+        #   # confirm_within = 3.days and confirmation_sent_at = 2.days.ago
+        #   confirmation_period_expired?  # returns false
+        #
+        #   # confirm_within = 3.days and confirmation_sent_at = 4.days.ago
+        #   confirmation_period_expired?  # returns true
+        #
+        #   # confirm_within = nil
+        #   confirmation_period_expired?  # will always return false
+        #
+        def confirmation_period_expired?
+          self.class.confirm_within && (Time.now > self.confirmation_sent_at + self.class.confirm_within )
+        end
+
+        # Checks whether the record requires any confirmation.
+        def pending_any_confirmation
+          if (!confirmed? || pending_reconfirmation?)
+            yield
+          else
+            self.errors.add(:email, :already_confirmed)
+            false
+          end
+        end
+
+        # Generates a new random token for confirmation, and stores the time
+        # this token is being generated
+        def generate_confirmation_token
+          self.confirmation_token   = self.class.confirmation_token
+          self.confirmation_sent_at = Time.now.utc
+        end
+
+        def generate_confirmation_token!
+          generate_confirmation_token && save(:validate => false)
+        end
+
+        def after_password_reset
+          super
+          confirm! unless confirmed?
+        end
+
+        def postpone_email_change_until_confirmation
+          @reconfirmation_required = true
+          self.unconfirmed_email = self.email
+          self.email = self.email_was
+        end
+
+        def postpone_email_change?
+          postpone = self.class.reconfirmable && email_changed? && !@bypass_postpone
+          @bypass_postpone = nil
+          postpone
+        end
+
+        def reconfirmation_required?
+          self.class.reconfirmable && @reconfirmation_required
+        end
+
+      module ClassMethods
+        # Attempt to find a user by its email. If a record is found, send new
+        # confirmation instructions to it. If not, try searching for a user by unconfirmed_email
+        # field. If no user is found, returns a new user with an email not found error.
+        # Options must contain the user email
+        def send_confirmation_instructions(attributes={})
+          confirmable = find_by_unconfirmed_email_with_errors(attributes) if reconfirmable
+          unless confirmable.try(:persisted?)
+            confirmable = find_or_initialize_with_errors(confirmation_keys, attributes, :not_found)
+          end
+          confirmable.resend_confirmation_token if confirmable.persisted?
+          confirmable
+        end
+
+        # Find a user by its confirmation token and try to confirm it.
+        # If no user is found, returns a new user with an error.
+        # If the user is already confirmed, create an error for the user
+        # Options must have the confirmation_token
+        def confirm_by_token(confirmation_token)
+          confirmable = find_or_initialize_with_error_by(:confirmation_token, confirmation_token)
+          confirmable.confirm! if confirmable.persisted?
+          confirmable
+        end
+
+        # Generate a token checking if one does not already exist in the database.
+        def confirmation_token
+          generate_token(:confirmation_token)
+        end
+
+        # Find a record for confirmation by unconfirmed email field
+        def find_by_unconfirmed_email_with_errors(attributes = {})
+          unconfirmed_required_attributes = confirmation_keys.map { |k| k == :email ? :unconfirmed_email : k }
+          unconfirmed_attributes = attributes.symbolize_keys
+          unconfirmed_attributes[:unconfirmed_email] = unconfirmed_attributes.delete(:email)
+          find_or_initialize_with_errors(unconfirmed_required_attributes, unconfirmed_attributes, :not_found)
+        end
+
+        Revise::Models.config(self, :allow_unconfirmed_access_for, :confirmation_keys, :reconfirmable, :confirm_within)
+      end
+    end
+  end
+end