devise_invitable 1.0.1 → 1.0.2

data/README.rdoc

@@ -1,5 +1,5 @@
 = DeviseInvitable
-{<img src="https://secure.travis-ci.org/scambra/devise_invitable.png"/>}[http://travis-ci.org/scambra/devise_invitable]
+{<img src="http://travis-ci.org/scambra/devise_invitable.png"/>}[http://travis-ci.org/scambra/devise_invitable]
 
 It adds support to devise[http://github.com/plataformatec/devise] for send invitations by email (it requires to be authenticated) and accept the invitation setting the password.
 
@@ -90,7 +90,7 @@ or directly as parameters to the <tt>devise</tt> method:
 
 * invitation_limit: The number of invitations users can send.  The default value of nil means users can send as many invites as they want.  A setting of 0 means they can't send invitations.  A setting n > 0 means they can send n invitations.
 
-* 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.
+* invite_key: The key to be used to check existing users when sending an invitation. You can use multiple keys. This value must be a hash with the invite key as hash keys, and regexp to validate format as values. If you don't to validate the key you can set nil as validation format. The default value is looking for users by email and validating with Devise.email_regexp {:email => Devise.email_regexp}.
 
 * validate_on_invite: force a record to be valid before being actually invited.
 
@@ -272,4 +272,4 @@ Special thanks to rymai[http://github.com/rymai] for the Rails 3 support, his fo
 
 == Copyright
 
-Copyright (c) 2009 Sergio Cambra. See LICENSE for details.
+Copyright (c) 2012 Sergio Cambra. See LICENSE for details.

data/app/controllers/devise/invitations_controller.rb~

@@ -0,0 +1,48 @@
+class Devise::InvitationsController < ApplicationController
+  include Devise::Controllers::InternalHelpers
+
+  before_filter :authenticate_inviter!, :only => [:new, :create]
+  before_filter :require_no_authentication, :only => [:edit, :update]
+  helper_method :after_sign_in_path_for
+
+  # GET /resource/invitation/new
+  def new
+    build_resource
+    render_with_scope :new
+  end
+
+  # POST /resource/invitation
+  def create
+    self.resource = resource_class.invite!(params[resource_name])
+
+    if resource.errors.empty?
+      puts params.inspect
+      set_flash_message :notice, :send_instructions, :email => self.resource.email
+      redirect_to after_sign_in_path_for(resource_name)
+    else
+      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] })
+      render_with_scope :edit
+    else
+      set_flash_message(:alert, :invitation_token_invalid)
+      redirect_to after_sign_out_path_for(resource_name)
+    end
+  end
+
+  # PUT /resource/invitation
+  def update
+    self.resource = resource_class.accept_invitation!(params[resource_name])
+
+    if resource.errors.empty?
+      set_flash_message :notice, :updated
+      sign_in_and_redirect(resource_name, resource)
+    else
+      render_with_scope :edit
+    end
+  end
+end

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

@@ -3,8 +3,10 @@
 <%= form_for resource, :as => resource_name, :url => invitation_path(resource_name), :html => {:method => :post} do |f| %>
   <%= devise_error_messages! %>
 
-  <p><%= f.label :email %><br />
-  <%= f.text_field :email %></p>
+<% resource.class.invite_key_fields.each do |field| -%>
+  <p><%= f.label field %><br />
+  <%= f.text_field field %></p>
+<% end -%>
 
   <p><%= f.submit "Send an invitation" %></p>
 <% end %>

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

@@ -0,0 +1,14 @@
+<h2>Send invitation</h2>
+
+<%= form_for resource, :as => resource_name, :url => invitation_path(resource_name), :html => {:method => :post} do |f| %>
+  <%= devise_error_messages! %>
+
+<% Array(resource.class.invite_key).each do |field| -%>
+  <p><%= f.label field %><br />
+  <%= f.text_field field %></p>
+<% end -%>
+
+  <p><%= f.submit "Send an invitation" %></p>
+<% end %>
+
+<%= link_to "Home", after_sign_in_path_for(resource_name) %><br />

data/lib/devise_invitable.rb

@@ -37,13 +37,14 @@ module Devise
   mattr_accessor :invitation_limit
   @@invitation_limit = nil
 
-  # Public: The key to be used to check existing users when sending an invitation
+  # Public: The key to be used to check existing users when sending an invitation,
+  # and the regexp used to test it when validate_on_invite is not set.
   #
   # Examples (in config/initializers/devise.rb)
   #
-  #   config.invite_key = :email
+  #   config.invite_key = {:email => /\A[^@]+@[^@]+\z/}
   mattr_accessor :invite_key
-  @@invite_key = :email
+  @@invite_key = {:email => Devise.email_regexp}
 
   # Public: Resend invitation if user with invited status is invited again
   # (default: true)

data/lib/devise_invitable.rb~

@@ -0,0 +1,68 @@
+require 'devise'
+
+module DeviseInvitable
+  autoload :Inviter, 'devise_invitable/inviter'
+end
+
+require 'devise_invitable/mailer'
+require 'devise_invitable/routes'
+require 'devise_invitable/controllers/url_helpers'
+require 'devise_invitable/controllers/registrations'
+require 'devise_invitable/controllers/helpers'
+require 'devise_invitable/rails'
+
+module Devise
+  # Public: Validity period of the invitation token (default: 0). If
+  # invite_for is 0 or nil, the invitation will never expire.
+  # Set invite_for in the Devise configuration file (in config/initializers/devise.rb).
+  #
+  #   config.invite_for = 2.weeks # => The invitation token will be valid 2 weeks
+  mattr_accessor :invite_for
+  @@invite_for = 0
+
+  # Public: Flag that force a record to be valid before being actually invited
+  # (default: false).
+  #
+  # Examples (in config/initializers/devise.rb)
+  #
+  #   config.validate_on_invite = true
+  mattr_accessor :validate_on_invite
+  @@validate_on_invite = false
+
+  # Public: number of invitations the user is allowed to send
+  #
+  # Examples (in config/initializers/devise.rb)
+  #
+  #   config.invitation_limit = nil
+  mattr_accessor :invitation_limit
+  @@invitation_limit = nil
+
+  # Public: The key to be used to check existing users when sending an invitation.
+  # It can be an array.
+  #
+  # Examples (in config/initializers/devise.rb)
+  #
+  #   config.invite_key = :email
+  mattr_accessor :invite_key
+  @@invite_key = :email
+
+  # Public: The regexp to be used to test invite key when sending an invitation.
+  # It must be a hash indexed by invite_key
+  #
+  # Examples (in config/initializers/devise.rb)
+  #
+  #   config.invite_key = :email
+  mattr_accessor :invite_key_validation_regexp
+  @@invite_key_validation_regexp = {:email => Devise.email_regexp}
+
+  # 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/devise_invitable/controllers/registrations.rb

@@ -1,36 +1,40 @@
 module DeviseInvitable::Controllers::Registrations
   def self.included(controller)
-    controller.send :around_filter, :destroy_if_previously_invited, :only => :create
+    controller.send :around_filter, :keep_invitation_info, :only => :create
   end
 
   protected
 
   def destroy_if_previously_invited
-    invitation_info = {}
-
     hash = params[resource_name]
     if hash && hash[:email]
-      resource = resource_class.first(:conditions => { :email => hash[:email], :encrypted_password => '' })
+      resource = resource_class.where(:email => hash[:email], :encrypted_password => '').first
       if resource
-        invitation_info[:invitation_sent_at] = resource[:invitation_sent_at]
-        invitation_info[:invited_by_id] = resource[:invited_by_id]
-        invitation_info[:invited_by_type] = resource[:invited_by_type]
+        @invitation_info = {}
+        @invitation_info[:invitation_sent_at] = resource[:invitation_sent_at]
+        @invitation_info[:invited_by_id] = resource[:invited_by_id]
+        @invitation_info[:invited_by_type] = resource[:invited_by_type]
         resource.destroy
       end
     end
-
-    # execute the action (create)
+  end
+  
+  def keep_invitation_info
+    resource_invitable = resource_class.devise_modules.include?(:invitable)
+    destroy_if_previously_invited if resource_invitable
     yield
-    # Note that the after_filter is executed at THIS position !
-
+    reset_invitation_info if resource_invitable
+  end
+  
+  def reset_invitation_info
     # Restore info about the last invitation (for later reference)
     # Reset the invitation_info only, if invited_by_id is still nil at this stage:
-    resource = resource_class.first(:conditions => { :email => hash[:email], :invited_by_id => nil })
-    if resource
-      resource[:invitation_sent_at] = invitation_info[:invitation_sent_at]
-      resource[:invited_by_id] = invitation_info[:invited_by_id]
-      resource[:invited_by_type] = invitation_info[:invited_by_type]
+    resource = resource_class.where(:email => params[resource_name][:email], :invited_by_id => nil).first
+    if resource && @invitation_info
+      resource[:invitation_sent_at] = @invitation_info[:invitation_sent_at]
+      resource[:invited_by_id] = @invitation_info[:invited_by_id]
+      resource[:invited_by_type] = @invitation_info[:invited_by_type]
       resource.save!
     end
   end
-end
+end

data/lib/devise_invitable/controllers/registrations.rb~

@@ -0,0 +1,43 @@
+module DeviseInvitable::Controllers::Registrations
+  def self.included(controller)
+    controller.send :around_filter, :keep_invitation_info, :only => :create
+  end
+
+  protected
+
+  def destroy_if_previously_invited
+    @invitation_info = {}
+
+    hash = params[resource_name]
+    if hash && hash[:email]
+      resource = resource_class.where(:email => hash[:email], :encrypted_password => '').first
+      if resource
+        @invitation_info[:invitation_sent_at] = resource[:invitation_sent_at]
+        @invitation_info[:invited_by_id] = resource[:invited_by_id]
+        @invitation_info[:invited_by_type] = resource[:invited_by_type]
+        resource.destroy
+      end
+    end
+  end
+  
+  def keep_invitation_info
+    resource_invitable = resource_class.devise_modules.include?(:invitable)
+    destroy_if_previously_invited if resource_invitable
+    yield
+    reset_invitation_info if resource_invitable
+  end
+  
+  def reset_invitation_info
+    puts @invitation_info.inspect
+    # Restore info about the last invitation (for later reference)
+    # Reset the invitation_info only, if invited_by_id is still nil at this stage:
+    resource = resource_class.where(:email => params[resource_name][:email], :invited_by_id => nil).first
+    puts resource.inspect
+    if resource
+      resource[:invitation_sent_at] = @invitation_info[:invitation_sent_at]
+      resource[:invited_by_id] = @invitation_info[:invited_by_id]
+      resource[:invited_by_type] = @invitation_info[:invited_by_type]
+      resource.save!
+    end
+  end
+end

data/lib/devise_invitable/model.rb

@@ -1,3 +1,5 @@
+require 'active_support/deprecation'
+
 module Devise
   module Models
     # Invitable is responsible for sending invitation emails.
@@ -13,7 +15,7 @@ module Devise
     #
     # Examples:
     #
-    #   User.find(1).invited?                               # => true/false
+    #   User.find(1).invited_to_sign_up?                    # => 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
@@ -22,6 +24,7 @@ module Devise
       extend ActiveSupport::Concern
 
       attr_accessor :skip_invitation
+      attr_accessor :completing_invite
 
       included do
         include ::DeviseInvitable::Inviter        
@@ -36,23 +39,35 @@ module Devise
       # 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.completing_invite = true
+        if self.invited_to_sign_up? && 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.completing_invite = false
             self.save(:validate => false)
           end
         end
       end
 
+      # Verifies whether a user has accepted an invite, was never invited, or is in the process of accepting an invitation, or not
+      def accepting_or_not_invited?
+        !!completing_invite || !invited_to_sign_up?
+      end
+
       # Verifies whether a user has been invited or not
-      def invited?
+      def invited_to_sign_up?
         persisted? && invitation_token.present?
       end
+      
+      def invited?
+        invited_to_sign_up?
+      end
+      deprecate :invited?
 
       # Reset invitation token and send invitation again
       def invite!
-        was_invited = invited?
+        was_invited = invited_to_sign_up?
         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
@@ -71,18 +86,25 @@ module Devise
       # 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?
+        invited_to_sign_up? && invitation_period_valid?
       end
 
       # Only verify password when is not invited
       def valid_password?(password)
-        super unless invited?
+        super unless invited_to_sign_up?
       end
       
       def reset_password!(new_password, new_password_confirmation)
         super
         accept_invitation!
       end
+      
+      def invite_key_valid?
+        return true unless self.class.invite_key.is_a? Hash # FIXME: remove this line when deprecation is removed
+        self.class.invite_key.all? do |key, regexp|
+          regexp.nil? || self.send(key).try(:match, regexp)
+        end
+      end
 
       protected
         # Overriding the method in Devise's :validatable module so password is not required on inviting
@@ -125,6 +147,16 @@ module Devise
         end
 
       module ClassMethods
+        # Return fields to invite
+        def invite_key_fields
+          if invite_key.is_a? Hash
+            invite_key.keys
+          else
+            ActiveSupport::Deprecation.warn("invite_key should be a hash like {#{invite_key.inspect} => /.../}")
+            Array(invite_key)
+          end
+        end
+        
         # 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.
@@ -132,16 +164,24 @@ module Devise
         # 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))
+          invite_key_array = invite_key_fields
+          attributes_hash = {}
+          invite_key_array.each do |k,v|
+            attributes_hash[k] = attributes.delete(k)
+          end
+
+          invitable = find_or_initialize_with_errors(invite_key_array, attributes_hash)
           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
+            invitable.errors.clear if !self.validate_on_invite and invitable.invite_key_valid?
+          elsif !invitable.invited_to_sign_up? || !self.resend_invitation
+            invite_key_array.each do |key|
+              invitable.errors.add(key, :taken)
+            end
           end
 
           if invitable.errors.empty?

data/lib/devise_invitable/model.rb~

@@ -0,0 +1,249 @@
+require 'active_support/deprecation'
+
+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_to_sign_up?                    # => 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
+      attr_accessor :completing_invite
+
+      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!
+        self.completing_invite = true
+        if self.invited_to_sign_up? && 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.completing_invite = false
+            self.save(:validate => false)
+          end
+        end
+      end
+
+      # Verifies whether a user has accepted an invite, was never invited, or is in the process of accepting an invitation, or not
+      def accepting_or_not_invited?
+        !!completing_invite || !invited_to_sign_up?
+      end
+
+      # Verifies whether a user has been invited or not
+      def invited_to_sign_up?
+        persisted? && invitation_token.present?
+      end
+      
+      def invited?
+        invited_to_sign_up?
+      end
+      deprecate :invited?
+
+      # Reset invitation token and send invitation again
+      def invite!
+        was_invited = invited_to_sign_up?
+        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
+        
+        # Call these before_validate methods since we aren't validating on save
+        self.downcase_keys if self.new_record? && self.respond_to?(:downcase_keys)
+        self.strip_whitespace if self.new_record? && self.respond_to?(:strip_whitespace)
+        
+        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_to_sign_up? && invitation_period_valid?
+      end
+
+      # Only verify password when is not invited
+      def valid_password?(password)
+        super unless invited_to_sign_up?
+      end
+      
+      def reset_password!(new_password, new_password_confirmation)
+        super
+        accept_invitation!
+      end
+      
+      def invite_key_valid?
+        return true unless self.class.invite_key.is_a? Hash # FIXME: remove this line when deprecation is removed
+        self.class.invite_key.all? do |key, regexp|
+          regexp.nil? || self.send(key).try(:match, regexp)
+        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
+
+        # 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
+        # Return fields to invite
+        def invite_key_fields
+          if invite_key.is_a? Hash
+            invite_key.keys
+          else
+            ActiveSupport::Deprecation.warn("invite_key should be a hash like {#{invite_key.inspect} => /.../}")
+            Array(invite_key)
+          end
+        end
+        
+        # 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)
+          invite_key_array = invite_key_fields
+          attributes_hash = {}
+          invite_key_array.each do |k,v|
+            attributes_hash[k] = attributes.delete(k)
+          end
+
+          invitable = find_or_initialize_with_errors(invite_key_array, attributes_hash)
+          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.invite_key_valid?
+          elsif !invitable.invited_to_sign_up? || !self.resend_invitation
+            invite_key_fields.each do |key|
+              invitable.errors.add(key, :taken)
+            end
+          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/version.rb

@@ -1,3 +1,3 @@
 module DeviseInvitable
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/lib/generators/devise_invitable/install_generator.rb

@@ -32,7 +32,9 @@ module DeviseInvitable
   # config.invitation_limit = 5
   
   # The key to be used to check existing users when sending an invitation
-  # config.invite_key = :email
+  # and the regexp used to test it when validate_on_invite is not set.
+  # config.invite_key = {:email => /\A[^@]+@[^@]+\z/}
+  # config.invite_key = {:email => /\A[^@]+@[^@]+\z/, :username => nil}
   
   # Flag that force a record to be valid before being actually invited 
   # Default: false

data/lib/generators/devise_invitable/install_generator.rb~

@@ -0,0 +1,54 @@
+module DeviseInvitable
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+      desc "Add DeviseInvitable config variables to the Devise initializer and copy DeviseInvitable locale files to your application."
+      
+      # def devise_install
+      #   invoke "devise:install"
+      # end
+      
+      def add_config_options_to_initializer
+        devise_initializer_path = "config/initializers/devise.rb"
+        if File.exist?(devise_initializer_path)
+          old_content = File.read(devise_initializer_path)
+          
+          if old_content.match(Regexp.new(/^\s# ==> Configuration for :invitable\n/))
+            false
+          else
+            inject_into_file(devise_initializer_path, :before => "  # ==> Configuration for :confirmable\n") do
+<<-CONTENT
+  # ==> Configuration for :invitable
+  # 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.
+  # config.invite_for = 2.weeks
+  
+  # Number of invitations users can send.
+  # If invitation_limit is nil, users can send unlimited invitations.
+  # If invitation_limit is 0, users can't send invitations.
+  # If invitation_limit n > 0, users can send n invitations.
+  # Default: nil
+  # config.invitation_limit = 5
+  
+  # The key to be used to check existing users when sending an invitation.
+  # config.invite_key = {:email => /\A[^@]+@[^@]+\z/}
+  # config.invite_key = {:email => /\A[^@]+@[^@]+\z/, :username => nil}
+  
+  # Flag that force a record to be valid before being actually invited 
+  # Default: false
+  # config.validate_on_invite = true
+
+CONTENT
+            end
+          end
+        end
+      end
+      
+      def copy_locale
+        copy_file "../../../config/locales/en.yml", "config/locales/devise_invitable.en.yml"
+      end
+      
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: devise_invitable
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Sergio Cambra
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-03 00:00:00 Z
+date: 2012-05-26 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler
@@ -74,27 +74,33 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- app/controllers/devise/invitations_controller.rb
+- app/views/devise/mailer/invitation_instructions.html.erb
+- app/views/devise/invitations/new.html.erb~
 - app/views/devise/invitations/edit.html.erb
 - app/views/devise/invitations/new.html.erb
-- app/views/devise/mailer/invitation_instructions.html.erb
+- app/controllers/devise/invitations_controller.rb
+- app/controllers/devise/invitations_controller.rb~
 - config/locales/en.yml
-- lib/devise_invitable/controllers/helpers.rb
-- lib/devise_invitable/controllers/registrations.rb
-- lib/devise_invitable/controllers/url_helpers.rb
-- lib/devise_invitable/inviter.rb
-- lib/devise_invitable/mailer.rb
+- lib/devise_invitable.rb
+- lib/devise_invitable.rb~
+- lib/devise_invitable/routes.rb
 - lib/devise_invitable/model.rb
 - lib/devise_invitable/rails.rb
-- lib/devise_invitable/routes.rb
+- lib/devise_invitable/mailer.rb
 - lib/devise_invitable/version.rb
-- lib/devise_invitable.rb
-- lib/generators/active_record/devise_invitable_generator.rb
+- lib/devise_invitable/model.rb~
+- lib/devise_invitable/inviter.rb
+- lib/devise_invitable/controllers/url_helpers.rb
+- lib/devise_invitable/controllers/helpers.rb
+- lib/devise_invitable/controllers/registrations.rb~
+- lib/devise_invitable/controllers/registrations.rb
 - lib/generators/active_record/templates/migration.rb
-- lib/generators/devise_invitable/devise_invitable_generator.rb
+- lib/generators/active_record/devise_invitable_generator.rb
+- lib/generators/mongoid/devise_invitable_generator.rb
 - lib/generators/devise_invitable/install_generator.rb
 - lib/generators/devise_invitable/views_generator.rb
-- lib/generators/mongoid/devise_invitable_generator.rb
+- lib/generators/devise_invitable/devise_invitable_generator.rb
+- lib/generators/devise_invitable/install_generator.rb~
 - LICENSE
 - README.rdoc
 homepage: https://github.com/scambra/devise_invitable
@@ -132,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: An invitation strategy for Devise