devise_invitable 0.4.0 → 0.6.1

data/README.rdoc

@@ -4,7 +4,7 @@ It adds support to devise[http://github.com/plataformatec/devise] for send invit
 
 DeviseInvitable currently only support Rails 3, if you want to use it with Rails 2.3 you must install version {0.2.3}[http://rubygems.org/gems/devise_invitable/versions/0.2.3]
 
-== Installation for Rails ~> 3.0 and Devise ~> 1.1
+== Installation for Rails ~> 3.0 and Devise ~> 1.2
 
 Install DeviseInvitable gem, it will also install dependencies (such as devise and warden):
 
@@ -12,8 +12,8 @@ Install DeviseInvitable gem, it will also install dependencies (such as devise a
 
 Add DeviseInvitable to your Gemfile (and Devise if you weren't using them):
 
-  gem 'devise',           '~> 1.1.3'
-  gem 'devise_invitable', '~> 0.3.4'
+  gem 'devise',           '~> 1.2.0'
+  gem 'devise_invitable', '~> 0.4.0'
 
 === Automatic installation
 
@@ -51,6 +51,7 @@ or for a model that already exists, define a migration to add DeviseInvitable to
   change_table :users do |t|
     t.string   :invitation_token, :limit => 60
     t.datetime :invitation_sent_at
+    t.datetime :invitation_accepted_at
     t.index    :invitation_token
   end
 
@@ -61,7 +62,7 @@ or for a model that already exists, define a migration to add DeviseInvitable to
 
 == Model configuration
 
-DeviseInvitable adds three new configuration options:
+DeviseInvitable adds some new configuration options:
 
 * invite_for: The period the generated invitation token is valid, after this period, the invited resource won't be able to accept the invitation. When invite_for is 0 (the default), the invitation won't expire.
 
@@ -81,6 +82,10 @@ or directly as parameters to the <tt>devise</tt> method:
 
 * invite_key: The key to be used to check existing users when sending an invitation. The key must be an unique field. The default value is looking for users by email.
 
+* validate_on_invite: force a record to be valid before being actually invited.
+
+* resend_invitation: resend invitation if user with invited status is invited again. Enabled by default.
+
 For more details, see <tt>config/initializers/devise.rb</tt> (after you invoked the "devise_invitable:install" generator described above).
 
 == Configuring views
@@ -95,6 +100,28 @@ You can also use the generator to generate scoped views:
 
 Please refer to {Devise's README}[http://github.com/plataformatec/devise] for more information about views.
 
+== Configuring controllers
+
+To change the controller's behavior, create a controller that inherits from <tt>Devise::InvitationsController</tt>. The available methods are: new, create, edit, and update. You should read the {original controllers source}[https://raw.github.com/scambra/devise_invitable/master/app/controllers/devise/invitations_controller.rb] before editing any of these actions. Your controller might now look something like this:
+
+   class Users::InvitationsController < Devise::InvitationsController
+     def update
+       if this
+         redirect_to root_path
+       else
+         super
+       end
+     end
+   end
+
+Now just tell Devise that you want to use your controller, the controller above is 'users/invitations', so our routes.rb would have this line:
+
+  devise_for :users, :controllers => { :invitations => 'users/invitations' }
+
+be sure that you generate the views and put them into the controller that you generated, so for this example it would be:
+
+  rails generate devise_invitable:views users/invitations
+
 == Usage
 
 === Send an invitation
@@ -122,14 +149,28 @@ To accept an invitation with a token use the <tt>accept_invitation!</tt> class m
 
   User.accept_invitation!(:invitation_token => params[:invitation_token], :password => "ad97nwj3o2", :name => "John Doe")
 
+=== Callbacks
+
+A callback event is fired before and after an invitation is accepted (User#accept_invitation!). For example, in your resource model you can add:
+
+  after_invitation_accepted :email_invited_by
+
+  def email_invited_by
+     # ... 
+  end
+
+The callbacks support all options and arguments available to the standard callbacks provided by AR.
+
 == Integration in a Rails application
 
 Since the invitations controller take care of all the creation/acceptation of an invitation, in most cases you wouldn't call the <tt>invite!</tt> and <tt>accept_invitation!</tt> methods directly.
 Instead, in your views, put a link to <tt>new_user_invitation_path</tt> or <tt>new_invitation_path(:user)</tt> or even <tt>/users/invitation/new</tt> to prepare and send an invitation (to a user in this example).
-After an invitation is created and sent, the inviter will be redirected to after_sign_in_path_for(resource_name).
+
+After an invitation is created and sent, the inviter will be redirected to after_invite_path_for(resource_name), which is stored path or the same path as after_sign_in_path_for by default.
+
+After an invitation is accepted, the invitee will be redirected to after_accept_path_for(resource), which is the same path as after_sign_in_path_for by default. If you want to override the path, override invitations controller and define after_accept_path_for method. This is useful in the common case that a user is invited to a specific location in your application. More on {Devise's README}[http://github.com/plataformatec/devise], "Controller filters and helpers" section.
 
 The invitation email includes a link to accept the invitation that looks like this:  <tt>/users/invitation/accept?invitation_token=abcd123</tt>. When clicked, the invited must set a password in order to accept its invitation. Note that if the invitation_token is not present or not valid, the invited is redirected to after_sign_out_path_for(resource_name).
-You can also overwrite after_sign_in_path_for and after_sign_out_path_for to customize your redirect hooks. More on {Devise's README}[http://github.com/plataformatec/devise], "Controller filters and helpers" section.
 
 The controller sets the invited_by_id attribute for the new user to the current user.  This will let you easily keep track of who invited who.
 
@@ -144,10 +185,29 @@ You would have a User model which is configured as invitable and an Admin model
   class ApplicationController < ActionController::Base
   protected
     def authenticate_inviter!
-      authenticate_admin!
+      authenticate_admin!(:force => true)
     end
   end
 
+And include DeviseInvitable::Inviter module into Admin model:
+
+  class Admin < ActiveRecord::Base
+    devise :database_authenticatable, :validatable
+    include DeviseInvitable::Inviter
+  end
+
+== Has many invitations
+
+If you want to get all records invited by a resource, you should define has_many association in the model allowed to send invitations.
+
+For the default behavior, define it like this:
+
+  has_many :invitations, :class_name => self.class.to_s, :as => :invited_by
+
+For the previous example, where admins send invitations to users, define it like this:
+
+  has_many :invitations, :class_name => 'User', :as => :invited_by
+
 == I18n
 
 DeviseInvitable uses flash messages with I18n with the flash keys <tt>:send_instructions</tt>, <tt>:invitation_token_invalid</tt> and <tt>:updated</tt>. To customize your app, you can modify the generated locale file:

data/app/controllers/devise/invitations_controller.rb

@@ -18,15 +18,15 @@ class Devise::InvitationsController < ApplicationController
 
     if resource.errors.empty?
       set_flash_message :notice, :send_instructions, :email => self.resource.email
-      redirect_to after_sign_in_path_for(resource_name)
+      respond_with resource, :location => after_invite_path_for(resource)
     else
-      render_with_scope :new
+      respond_with_navigational(resource) { render_with_scope :new }
     end
   end
 
   # GET /resource/invitation/accept?invitation_token=abcdef
   def edit
-    if params[:invitation_token] && self.resource = resource_class.first(:conditions => { :invitation_token => params[:invitation_token] })
+    if params[:invitation_token] && self.resource = resource_class.to_adapter.find_first( :invitation_token => params[:invitation_token] )
       render_with_scope :edit
     else
       set_flash_message(:alert, :invitation_token_invalid)
@@ -40,9 +40,10 @@ class Devise::InvitationsController < ApplicationController
 
     if resource.errors.empty?
       set_flash_message :notice, :updated
-      sign_in_and_redirect(resource_name, resource)
+      sign_in(resource_name, resource)
+      respond_with resource, :location => after_accept_path_for(resource)
     else
-      render_with_scope :edit
+      respond_with_navigational(resource){ render_with_scope :edit }
     end
   end
 
@@ -54,8 +55,17 @@ class Devise::InvitationsController < ApplicationController
   def has_invitations_left?
     unless current_inviter.nil? || current_inviter.has_invitations_left?
       build_resource
-      set_flash_message :alert, :no_invitations_remaining 
-      render_with_scope :new
+      set_flash_message :alert, :no_invitations_remaining
+      respond_with_navigational(resource) { render_with_scope :new }
     end
   end
+
+  def after_invite_path_for(resource)
+    after_sign_in_path_for(resource)
+  end
+
+  def after_accept_path_for(resource)
+    after_sign_in_path_for(resource)
+  end
 end
+

data/app/views/devise/invitations/new.html.erb

@@ -1,6 +1,6 @@
 <h2>Send invitation</h2>
 
-<%= form_for resource, :as => resource_name, :url => invitation_path(resource_name) do |f| %>
+<%= form_for resource, :as => resource_name, :url => invitation_path(resource_name), :html => {:method => :post} do |f| %>
   <%= devise_error_messages! %>
 
   <p><%= f.label :email %><br />

data/lib/devise_invitable/controllers/helpers.rb

@@ -1,7 +1,7 @@
 module DeviseInvitable::Controllers::Helpers
   protected
   def authenticate_inviter!
-    send(:"authenticate_#{resource_name}!", true)
+    send(:"authenticate_#{resource_name}!", :force => true)
   end
 end
 ActionController::Base.send :include, DeviseInvitable::Controllers::Helpers

data/lib/devise_invitable/inviter.rb

@@ -0,0 +1,39 @@
+module DeviseInvitable
+  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?
+        if invitation_limit
+          return invitation_limit > 0
+        else
+          return self.class.invitation_limit > 0
+        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
+      Devise::Models.config(self, :invitation_limit)
+    end
+  end
+end

data/lib/devise_invitable/mailer.rb

@@ -3,12 +3,7 @@ module DeviseInvitable
     
     # Deliver an invitation email
     def invitation_instructions(record)
-      setup_mail(record, :invitation_instructions)
-    end
-    
-    def invitation(record)
-      ActiveSupport::Deprecation.warn('invitation has been renamed to invitation_instructions')
-      invitation_instructions(record)
+      devise_mail(record, :invitation_instructions)
     end
   end
 end

data/lib/devise_invitable/model.rb

@@ -24,15 +24,24 @@ module Devise
       attr_accessor :skip_invitation
 
       included do
+        include ::DeviseInvitable::Inviter        
         belongs_to :invited_by, :polymorphic => true
+        
+        include ActiveSupport::Callbacks
+        define_callbacks :invitation_accepted
+        
+        attr_writer :skip_password
       end
 
-      # Accept an invitation by clearing invitation token and confirming it if model
-      # is confirmable
+      # Accept an invitation by clearing invitation token and and setting invitation_accepted_at
+      # Confirms it if model is confirmable
       def accept_invitation!
         if self.invited? && self.valid?
-          self.invitation_token = nil
-          self.save
+          run_callbacks :invitation_accepted do
+            self.invitation_token = nil
+            self.invitation_accepted_at = Time.now.utc if respond_to? :"invitation_accepted_at="
+            self.save(:validate => false)
+          end
         end
       end
 
@@ -41,30 +50,15 @@ module Devise
         persisted? && invitation_token.present?
       end
 
-      # Return true if this user has invitations left to send
-      def has_invitations_left?
-        if self.class.invitation_limit.present?
-          if invitation_limit
-            return invitation_limit > 0
-          else
-            return self.class.invitation_limit > 0
-          end
-        else
-          return true
-        end
-      end
-
       # Reset invitation token and send invitation again
       def invite!
-        if new_record? || invited?
-          @skip_password = true
-          self.skip_confirmation! if self.new_record? && self.respond_to?(:skip_confirmation!)
-          generate_invitation_token if self.invitation_token.nil?
-          self.invitation_sent_at = Time.now.utc
-          if save(:validate => self.class.validate_on_invite)
-            self.invited_by.decrement_invitation_limit! if self.invited_by
-            !!deliver_invitation unless @skip_invitation
-          end
+        was_invited = invited?
+        self.skip_confirmation! if self.new_record? && self.respond_to?(:skip_confirmation!)
+        generate_invitation_token if self.invitation_token.nil?
+        self.invitation_sent_at = Time.now.utc
+        if save(:validate => false)
+          self.invited_by.decrement_invitation_limit! if !was_invited and self.invited_by.present?
+          deliver_invitation unless @skip_invitation
         end
       end
 
@@ -79,15 +73,13 @@ module Devise
       def valid_password?(password)
         super unless invited?
       end
+      
+      def reset_password!(new_password, new_password_confirmation)
+        super
+        accept_invitation!
+      end
 
       protected
-        def decrement_invitation_limit!
-          if self.class.invitation_limit.present?
-            self.invitation_limit ||= self.class.invitation_limit
-            self.decrement!(:invitation_limit)
-          end
-        end
-
         # Overriding the method in Devise's :validatable module so password is not required on inviting
         def password_required?
           !@skip_password && super
@@ -98,12 +90,6 @@ module Devise
           ::Devise.mailer.invitation_instructions(self).deliver
         end
 
-        # Clear invitation token when reset password token is cleared too
-        def clear_reset_password_token
-          self.invitation_token = nil if invited?
-          super
-        end
-
         # Checks if the invitation for the user is within the limit time.
         # We do this by calculating if the difference between today and the
         # invitation sent date does not exceed the invite for time configured.
@@ -137,25 +123,45 @@ module Devise
         # Attempt to find a user by it's email. If a record is not found, create a new
         # user and send invitation to it. If user is found, returns the user with an
         # email already exists error.
+        # If user is found and still have pending invitation, email is resend unless
+        # resend_invitation is set to false
         # Attributes must contain the user email, other attributes will be set in the record
-        def invite!(attributes={}, invited_by=nil, &block)
+        def _invite(attributes={}, invited_by=nil, &block)
           invitable = find_or_initialize_with_error_by(invite_key, attributes.delete(invite_key))
-          invitable.attributes = attributes
+          invitable.assign_attributes(attributes, :as => inviter_role(invited_by))
           invitable.invited_by = invited_by
 
+          invitable.skip_password = true
+          invitable.valid? if self.validate_on_invite
           if invitable.new_record?
-            invitable.errors.clear if invitable.email.try(:match, Devise.email_regexp)
+            invitable.errors.clear if !self.validate_on_invite and invitable.email.try(:match, Devise.email_regexp)
           else
-            invitable.errors.add(invite_key, :taken) unless invitable.invited?
+            invitable.errors.add(invite_key, :taken) unless invitable.invited? && self.resend_invitation
           end
 
           if invitable.errors.empty?
             yield invitable if block_given?
-            invitable.invite!
+            mail = invitable.invite!
           end
+          [invitable, mail]
+        end
+        
+        # Override this method if the invitable is using Mass Assignment Security
+        # and the inviter has a non-default role.
+        def inviter_role(inviter)
+          :default
+        end
+
+        def invite!(attributes={}, invited_by=nil, &block)
+          invitable, mail = _invite(attributes, invited_by, &block)
           invitable
         end
 
+        def invite_mail!(attributes={}, invited_by=nil, &block)
+          invitable, mail = _invite(attributes, invited_by, &block)
+          mail
+        end
+
         # Attempt to find a user by it's invitation_token to set it's password.
         # If a user is found, reset it's password and automatically try saving
         # the record. If not user is found, returns a new user containing an
@@ -175,12 +181,24 @@ module Devise
         def invitation_token
           generate_token(:invitation_token)
         end
+        
+        # Callback convenience methods
+        def before_invitation_accepted(*args, &blk)
+          set_callback(:invitation_accepted, :before, *args, &blk)
+        end
+        
+        def after_invitation_accepted(*args, &blk)
+          set_callback(:invitation_accepted, :after, *args, &blk)
+        end
+        
 
         Devise::Models.config(self, :invite_for)
         Devise::Models.config(self, :validate_on_invite)
         Devise::Models.config(self, :invitation_limit)
         Devise::Models.config(self, :invite_key)
+        Devise::Models.config(self, :resend_invitation)
       end
     end
   end
 end
+

data/lib/devise_invitable/model.rb~

@@ -0,0 +1,210 @@
+module Devise
+  module Models
+    # Invitable is responsible for sending invitation emails.
+    # When an invitation is sent to an email address, an account is created for it.
+    # Invitation email contains a link allowing the user to accept the invitation
+    # by setting a password (as reset password from Devise's recoverable module).
+    #
+    # Configuration:
+    #
+    #   invite_for: The period the generated invitation token is valid, after
+    #               this period, the invited resource won't be able to accept the invitation.
+    #               When invite_for is 0 (the default), the invitation won't expire.
+    #
+    # Examples:
+    #
+    #   User.find(1).invited?                               # => true/false
+    #   User.invite!(:email => 'someone@example.com')       # => send invitation
+    #   User.accept_invitation!(:invitation_token => '...') # => accept invitation with a token
+    #   User.find(1).accept_invitation!                     # => accept invitation
+    #   User.find(1).invite!                                # => reset invitation status and send invitation again
+    module Invitable
+      extend ActiveSupport::Concern
+
+      attr_accessor :skip_invitation
+
+      included do
+        include ::DeviseInvitable::Inviter        
+        belongs_to :invited_by, :polymorphic => true
+        
+        include ActiveSupport::Callbacks
+        define_callbacks :invitation_accepted
+        
+        attr_writer :skip_password
+      end
+
+      # Accept an invitation by clearing invitation token and and setting invitation_accepted_at
+      # Confirms it if model is confirmable
+      def accept_invitation!
+        if self.invited? && self.valid?
+          run_callbacks :invitation_accepted do
+            self.invitation_token = nil
+            self.invitation_accepted_at = Time.now.utc if respond_to? :"invitation_accepted_at="
+            self.save(:validate => false)
+          end
+        end
+      end
+
+      # Verifies whether a user has been invited or not
+      def invited?
+        persisted? && invitation_token.present?
+      end
+
+      # Reset invitation token and send invitation again
+      def invite!
+        was_invited = invited?
+        self.skip_confirmation! if self.new_record? && self.respond_to?(:skip_confirmation!)
+        generate_invitation_token if self.invitation_token.nil?
+        self.invitation_sent_at = Time.now.utc
+        if save(:validate => false)
+          self.invited_by.decrement_invitation_limit! if !was_invited and self.invited_by.present?
+          deliver_invitation unless @skip_invitation
+        end
+      end
+
+      # Verify whether a invitation is active or not. If the user has been
+      # invited, we need to calculate if the invitation time has not expired
+      # for this user, in other words, if the invitation is still valid.
+      def valid_invitation?
+        invited? && invitation_period_valid?
+      end
+
+      # Only verify password when is not invited
+      def valid_password?(password)
+        super unless invited?
+      end
+=begin      
+      def reset_password!(new_password, new_password_confirmation)
+        super
+        accept_invitation!
+      end
+=end
+      protected
+        # Overriding the method in Devise's :validatable module so password is not required on inviting
+        def password_required?
+          !@skip_password && super
+        end
+
+        # Deliver the invitation email
+        def deliver_invitation
+          ::Devise.mailer.invitation_instructions(self).deliver
+        end
+
+        # Clear invitation token when reset password token is cleared too
+        def clear_reset_password_token
+          self.invitation_token = nil if invited?
+          super
+        end
+
+        # Checks if the invitation for the user is within the limit time.
+        # We do this by calculating if the difference between today and the
+        # invitation sent date does not exceed the invite for time configured.
+        # Invite_for is a model configuration, must always be an integer value.
+        #
+        # Example:
+        #
+        #   # invite_for = 1.day and invitation_sent_at = today
+        #   invitation_period_valid?   # returns true
+        #
+        #   # invite_for = 5.days and invitation_sent_at = 4.days.ago
+        #   invitation_period_valid?   # returns true
+        #
+        #   # invite_for = 5.days and invitation_sent_at = 5.days.ago
+        #   invitation_period_valid?   # returns false
+        #
+        #   # invite_for = nil
+        #   invitation_period_valid?   # will always return true
+        #
+        def invitation_period_valid?
+          invitation_sent_at && (self.class.invite_for.to_i.zero? || invitation_sent_at.utc >= self.class.invite_for.ago)
+        end
+
+        # Generates a new random token for invitation, and stores the time
+        # this token is being generated
+        def generate_invitation_token
+          self.invitation_token   = self.class.invitation_token
+        end
+
+      module ClassMethods
+        # Attempt to find a user by it's email. If a record is not found, create a new
+        # user and send invitation to it. If user is found, returns the user with an
+        # email already exists error.
+        # If user is found and still have pending invitation, email is resend unless
+        # resend_invitation is set to false
+        # Attributes must contain the user email, other attributes will be set in the record
+        def _invite(attributes={}, invited_by=nil, &block)
+          invitable = find_or_initialize_with_error_by(invite_key, attributes.delete(invite_key))
+          invitable.assign_attributes(attributes, :as => inviter_role(invited_by))
+          invitable.invited_by = invited_by
+
+          invitable.skip_password = true
+          invitable.valid? if self.validate_on_invite
+          if invitable.new_record?
+            invitable.errors.clear if !self.validate_on_invite and invitable.email.try(:match, Devise.email_regexp)
+          else
+            invitable.errors.add(invite_key, :taken) unless invitable.invited? && self.resend_invitation
+          end
+
+          if invitable.errors.empty?
+            yield invitable if block_given?
+            mail = invitable.invite!
+          end
+          [invitable, mail]
+        end
+        
+        # Override this method if the invitable is using Mass Assignment Security
+        # and the inviter has a non-default role.
+        def inviter_role(inviter)
+          :default
+        end
+
+        def invite!(attributes={}, invited_by=nil, &block)
+          invitable, mail = _invite(attributes, invited_by, &block)
+          invitable
+        end
+
+        def invite_mail!(attributes={}, invited_by=nil, &block)
+          invitable, mail = _invite(attributes, invited_by, &block)
+          mail
+        end
+
+        # Attempt to find a user by it's invitation_token to set it's password.
+        # If a user is found, reset it's password and automatically try saving
+        # the record. If not user is found, returns a new user containing an
+        # error in invitation_token attribute.
+        # Attributes must contain invitation_token, password and confirmation
+        def accept_invitation!(attributes={})
+          invitable = find_or_initialize_with_error_by(:invitation_token, attributes.delete(:invitation_token))
+          invitable.errors.add(:invitation_token, :invalid) if invitable.invitation_token && invitable.persisted? && !invitable.valid_invitation?
+          if invitable.errors.empty?
+            invitable.attributes = attributes
+            invitable.accept_invitation!
+          end
+          invitable
+        end
+
+        # Generate a token checking if one does not already exist in the database.
+        def invitation_token
+          generate_token(:invitation_token)
+        end
+        
+        # Callback convenience methods
+        def before_invitation_accepted(*args, &blk)
+          set_callback(:invitation_accepted, :before, *args, &blk)
+        end
+        
+        def after_invitation_accepted(*args, &blk)
+          set_callback(:invitation_accepted, :after, *args, &blk)
+        end
+        
+
+        Devise::Models.config(self, :invite_for)
+        Devise::Models.config(self, :validate_on_invite)
+        Devise::Models.config(self, :invitation_limit)
+        Devise::Models.config(self, :invite_key)
+        Devise::Models.config(self, :resend_invitation)
+      end
+    end
+  end
+end
+

data/lib/devise_invitable/rails.rb

@@ -4,7 +4,10 @@ module DeviseInvitable
     ActiveSupport.on_load(:action_controller) { include DeviseInvitable::Controllers::UrlHelpers }
     ActiveSupport.on_load(:action_view)       { include DeviseInvitable::Controllers::UrlHelpers }
     
-    config.after_initialize do
+    # We use to_prepare instead of after_initialize here because Devise is a Rails engine; its
+    # mailer is reloaded like the rest of the user's app.  Got to make sure that our mailer methods
+    # are included each time Devise::Mailer is (re)loaded.
+    config.to_prepare do
       require 'devise/mailer'
       Devise::Mailer.send :include, DeviseInvitable::Mailer
     end

data/lib/devise_invitable/schema.rb

@@ -16,6 +16,7 @@ module DeviseInvitable
     #   change_table :the_resources do |t|
     #     t.string   :invitation_token, :limit => 60
     #     t.datetime :invitation_sent_at
+    #     t.datetime :invitation_accepted_at
     #     t.index    :invitation_token # for invitable
     #   end
     #
@@ -26,6 +27,7 @@ module DeviseInvitable
     def invitable
       apply_devise_schema :invitation_token,   String, :limit => 60
       apply_devise_schema :invitation_sent_at, DateTime
+      apply_devise_schema :invitation_accepted_at, DateTime
       apply_devise_schema :invitation_limit, Integer
       apply_devise_schema :invited_by_id, Integer
       apply_devise_schema :invited_by_type, String

data/lib/devise_invitable/version.rb

@@ -1,3 +1,3 @@
 module DeviseInvitable
-  VERSION = '0.4.0'
+  VERSION = '0.6.1'
 end

data/lib/devise_invitable.rb

@@ -1,5 +1,9 @@
 require 'devise'
 
+module DeviseInvitable
+  autoload :Inviter, 'devise_invitable/inviter'
+end
+
 require 'devise_invitable/mailer'
 require 'devise_invitable/routes'
 require 'devise_invitable/schema'
@@ -40,6 +44,15 @@ module Devise
   #   config.invite_key = :email
   mattr_accessor :invite_key
   @@invite_key = :email
+
+  # Public: Resend invitation if user with invited status is invited again
+  # (default: true)
+  #
+  # Example (in config/initializers/devise.rb)
+  #
+  #   config.resend_invitation = false
+  mattr_accessor :resend_invitation
+  @@resend_invitation = true
 end
 
 Devise.add_module :invitable, :controller => :invitations, :model => 'devise_invitable/model', :route => :invitation

data/lib/generators/active_record/templates/migration.rb

@@ -3,6 +3,7 @@ class DeviseInvitableAddTo<%= table_name.camelize %> < ActiveRecord::Migration
     change_table :<%= table_name %> do |t|
       t.string     :invitation_token, :limit => 60
       t.datetime   :invitation_sent_at
+      t.datetime   :invitation_accepted_at
       t.integer    :invitation_limit
       t.references :invited_by, :polymorphic => true
       t.index      :invitation_token # for invitable
@@ -18,8 +19,8 @@ class DeviseInvitableAddTo<%= table_name.camelize %> < ActiveRecord::Migration
   
   def self.down
     change_table :<%= table_name %> do |t|
-      remove_references :invited_by, :polymorphic => true
-      remove :invitation_limit, :invitation_sent_at, :invitation_token
+      t.remove_references :invited_by, :polymorphic => true
+      t.remove :invitation_limit, :invitation_sent_at, :invitation_accepted_at, :invitation_token
     end
   end
 end

data/lib/generators/devise_invitable/install_generator.rb

@@ -34,6 +34,10 @@ module DeviseInvitable
   # The key to be used to check existing users when sending an invitation
   # config.invite_key = :email
   
+  # Flag that force a record to be valid before being actually invited 
+  # Default: false
+  # config.validate_on_invite = true
+
 CONTENT
             end
           end

data/lib/generators/devise_invitable/views_generator.rb

@@ -2,9 +2,18 @@ require 'generators/devise/views_generator'
 
 module DeviseInvitable
   module Generators
-    class ViewsGenerator < Devise::Generators::ViewsGenerator
-      source_root File.expand_path("../../../../app/views", __FILE__)
+    class ViewsGenerator < Rails::Generators::Base
       desc 'Copies all DeviseInvitable views to your application.'
+
+      argument :scope, :required => false, :default => nil,
+                       :desc => "The scope to copy views to"
+
+      include ::Devise::Generators::ViewPathTemplates
+      source_root File.expand_path("../../../../app/views/devise", __FILE__)
+      def copy_views
+        view_directory :invitations
+        view_directory :mailer
+      end
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: devise_invitable
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 5
   prerelease: 
   segments: 
   - 0
-  - 4
-  - 0
-  version: 0.4.0
+  - 6
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Sergio Cambra
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-31 00:00:00 +02:00
-default_executable: 
+date: 2011-12-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler
@@ -42,12 +41,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
         - 3
+        - 1
         - 0
-        - 0
-        version: 3.0.0
+        version: 3.1.0
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -56,14 +55,21 @@ dependencies:
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 11
         segments: 
         - 1
-        - 2
-        - 0
-        version: 1.2.0
+        - 4
+        - 6
+        version: 1.4.6
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 6
+        version: "1.6"
   type: :runtime
   version_requirements: *id003
 description: It adds support for send invitations by email (it requires to be authenticated) and accept the invitation by setting a password.
@@ -90,6 +96,8 @@ files:
 - lib/devise_invitable/controllers/helpers.rb
 - lib/devise_invitable/controllers/url_helpers.rb
 - lib/devise_invitable/version.rb
+- lib/devise_invitable/inviter.rb
+- lib/devise_invitable/model.rb~
 - lib/generators/active_record/devise_invitable_generator.rb
 - lib/generators/active_record/templates/migration.rb
 - lib/generators/devise_invitable/views_generator.rb
@@ -98,7 +106,6 @@ files:
 - lib/generators/mongoid/devise_invitable_generator.rb
 - LICENSE
 - README.rdoc
-has_rdoc: true
 homepage: https://github.com/scambra/devise_invitable
 licenses: []
 
@@ -134,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: An invitation strategy for Devise