sparkly-auth 1.0.2 → 1.1.0

data/generators/sparkly/templates/views/sparkly_accounts/edit.html.erb

@@ -1,24 +1,6 @@
-<%form_for model, :url => model_path do |f|%>
-  <p>
-    <%=f.error_messages%>
-  </p>
-  
-  <p>
-    <%=f.label model_config.key%><br/>
-    <%=f.text_field model_config.key%>
-  </p>
-  
-  <p>
-    <%=f.label :password%><br/>
-    <%=f.password_field :password, :value => ''%>
-  </p>
-  
-  <p>
-    <%=f.label :password_confirmation%><br/>
-    <%=f.password_field :password_confirmation, :value => ''%>
-  </p>
-  
-  <p>
-    <%=f.submit "Update Profile"%>
-  </p>
+<%if Rails::VERSION::MAJOR == 2%>
+  <%=render :partial => 'rails2_form'%>
+<%else%>
+  <%=render :partial => 'rails3_form'%>
 <%end%>
+

data/generators/sparkly/templates/views/sparkly_accounts/new.html.erb

@@ -1,24 +1,5 @@
-<%form_for model, :url => model_path do |f|%>
-  <p>
-    <%=f.error_messages%>
-  </p>
-  
-  <p>
-    <%=f.label model_config.key%><br/>
-    <%=f.text_field model_config.key%>
-  </p>
-  
-  <p>
-    <%=f.label :password%><br/>
-    <%=f.password_field :password, :value => ''%>
-  </p>
-  
-  <p>
-    <%=f.label :password_confirmation%><br/>
-    <%=f.password_field :password_confirmation, :value => ''%>
-  </p>
-  
-  <p>
-    <%=f.submit "Sign up"%>
-  </p>
+<%if Rails::VERSION::MAJOR == 2%>
+  <%=render :partial => 'rails2_form'%>
+<%else%>
+  <%=render :partial => 'rails3_form'%>
 <%end%>

data/generators/sparkly/templates/views/sparkly_sessions/_rails2_form.html.erb

@@ -0,0 +1,22 @@
+<%form_for model, :url => model_session_path do |f|%>
+  <p>
+    <%=f.label model_config.key%><br/>
+    <%=f.text_field model_config.key%>
+  </p>
+  
+  <p>
+    <%=f.label :password%><br/>
+    <%=f.password_field :password, :value => ''%>
+  </p>
+  
+  <%if sparkly_config.remember_me.enabled?%>
+    <p>
+      <%=f.check_box :remember_me, :checked => false%>
+      <%=f.label :remember_me%>
+    </p>
+  <%end%>
+  
+  <p>
+    <%=f.submit "Sign in"%>
+  </p>
+<%end%>

data/generators/sparkly/templates/views/sparkly_sessions/_rails3_form.html.erb

@@ -0,0 +1,22 @@
+<%=form_for model, :url => model_session_path do |f|%>
+  <p>
+    <%=f.label model_config.key%><br/>
+    <%=f.text_field model_config.key%>
+  </p>
+  
+  <p>
+    <%=f.label :password%><br/>
+    <%=f.password_field :password, :value => ''%>
+  </p>
+  
+  <%if sparkly_config.remember_me.enabled?%>
+    <p>
+      <%=f.check_box :remember_me, :checked => false%>
+      <%=f.label :remember_me%>
+    </p>
+  <%end%>
+  
+  <p>
+    <%=f.submit "Sign in"%>
+  </p>
+<%end%>

data/generators/sparkly/templates/views/sparkly_sessions/new.html.erb

@@ -1,22 +1,5 @@
-<%form_for model, :url => model_session_path do |f|%>
-  <p>
-    <%=f.label model_config.key%><br/>
-    <%=f.text_field model_config.key%>
-  </p>
-  
-  <p>
-    <%=f.label :password%><br/>
-    <%=f.password_field :password, :value => ''%>
-  </p>
-  
-  <%if Auth.remember_me.enabled?%>
-    <p>
-      <%=f.check_box :remember_me, :checked => false%>
-      <%=f.label :remember_me%>
-    </p>
-  <%end%>
-  
-  <p>
-    <%=f.submit "Sign in"%>
-  </p>
+<%if Rails::VERSION::MAJOR == 2%>
+  <%=render :partial => 'rails2_form'%>
+<%else%>
+  <%=render :partial => 'rails3_form'%>
 <%end%>

data/lib/auth.rb

@@ -1,7 +1,7 @@
 module Auth
   class << self
     public :delegate
-    delegate :path, :encryptor, :default_accounts_controller_name, :default_sessions_controller_name,
+    delegate :encryptor, :default_accounts_controller_name, :default_sessions_controller_name,
              :password_update_frequency, :base_controller, :login_required_message, :logout_required_message,
              :default_destination, :session_duration, :invalid_credentials_message, :login_successful_message,
              :logout_message, :session_timeout_message, :default_login_path, :account_deleted_message,
@@ -19,6 +19,22 @@ module Auth
       yield configuration
     end
     
+    def defer_kickstart?
+      @defer_kickstart ||= !!ENV['DEFER_SPARKLY']
+    end
+    
+    def defer_kickstart=(a)
+      @defer_kickstart = !!a
+    end
+    
+    def path
+      if @configuration
+        @configuration.path
+      else
+        File.dirname(__FILE__)
+      end
+    end
+    
     # Applies all configuration settings. This is done by the Auth system after it has been configured but before
     # it processes any requests.
     def configure!
@@ -50,3 +66,8 @@ module Auth
     alias_method :kick!, :configure!
   end
 end
+
+if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  # Rails 3 doesn't load rails/init.rb first, so we need to do that ourselves.
+  require File.join(File.dirname(__FILE__), "../rails/init")
+end

data/lib/auth/behavior/base.rb

@@ -1,32 +1,30 @@
 class Auth::Behavior::Base
+  #unloadable
+  
+  attr_reader :options
   class_inheritable_array :migrations
   read_inheritable_attribute(:migrations) || write_inheritable_attribute(:migrations, [])
   
-  class << self
-    def apply_to_controllers
-      # Add additional methods to ApplicationController (or whatever controller Sparkly is told to use)
-      Auth.base_controller.send(:include, "#{name}::ControllerExtensions".constantize)
-      # why this doesn't work in cuke?
-  #    if (container = self.class).const_defined?(:ControllerExtensions)
-  #      Auth.base_controller.send(:include, container.const_get(:ControllerExtensions))
-  #    end
-    #rescue NameError
+  def apply(model_config)
+    track_behavior(model = model_config.target) do
+      apply_to_user(model)
+      apply_to_password(Password, model)
+      apply_to_controller(Auth.base_controller, model)
     end
   end
   
-  def apply_to(model)
-    track_behavior(model.target) do
-      apply_to_accounts(model)
-      apply_to_passwords(Password)
-    end
+  alias_method :apply_to, :apply
+  
+  def apply_to_controller(base_controller, user_model)
+    be_sure_to_override("apply_to_controller(base_controller, user_model)")
   end
 
-  def apply_to_passwords(password_model)
-    raise NotImplementedError, "Be sure to override #apply_to_passwords(passwords_model) in your Auth Behavior"
+  def apply_to_password(password_model, user_model)
+    be_sure_to_override("apply_to_password(password_model, user_model)")
   end
   
-  def apply_to_accounts(model_config)
-    raise NotImplementedError, "Be sure to override #apply_to_accounts(model_config) in your Auth Behavior"
+  def apply_to_user(user_model)
+    be_sure_to_override("apply_to_user(user_model)")
   end
   
   private
@@ -52,6 +50,11 @@ class Auth::Behavior::Base
   def behavior_name
     self.class.name
   end
+  
+  private
+  def be_sure_to_override(name)
+    raise NotImplementedError, "Be sure to override ##{name} in #{self.class.name}"
+  end
 
   public
   class << self
@@ -60,5 +63,9 @@ class Auth::Behavior::Base
     def migration(filename)
       migrations << filename unless migrations.include?(filename)
     end
+    
+#    def inherited(base)
+#      base.instance_eval { unloadable } # is this necessary?
+#    end
   end
 end

data/lib/auth/behavior/base/configuration.rb

@@ -0,0 +1,37 @@
+class Auth::Behavior::Base::Configuration
+  # Provides a handle back to the root configuration object.
+  attr_reader :configuration
+
+  include Auth::Configuration::Keys
+  
+  class << self
+    def configuration_name(new_name = nil)
+      if new_name
+        @configuration_name = new_name.to_sym
+      else
+        # the sub removes Configuration, ie Auth::Behavior::Core::Configuration becomes Auth::Behavior::Core
+        @configuration_name = name.sub(/\:\:[^\:]*$/, '').demodulize.underscore.to_sym
+      end
+    end
+  end
+  
+  # Returns true if the root configuration object's behaviors include :remember_me.
+  def enabled?
+    configuration.behaviors.include? configuration_name
+  end
+  
+  def configuration_name
+    self.class.configuration_name
+  end
+  
+  def initialize(configuration)
+    @configuration = configuration
+    defaults!
+  end
+  
+  def defaults!
+    raise "Don't forget to override #{self.class.name}#defaults!"
+  end
+  
+  alias reset! defaults!
+end

data/lib/auth/behavior/core.rb

@@ -17,15 +17,20 @@ module Auth
     class Core < Auth::Behavior::Base
       migration "create_sparkly_passwords"
       
-      def apply_to_passwords(password_model)
+      def apply_to_controller(base_controller, user_model)
+        base_controller.send(:include, Auth::Behavior::Core::ControllerExtensions)
+      end
+      
+      def apply_to_password(password_model, user_model)
+        config = user_model.sparkly_config
         password_model.instance_eval do
           belongs_to :authenticatable, :polymorphic => true
           
-          validates_length_of :unencrypted_secret, :minimum => Auth.minimum_password_length,
-                              :message => "must be at least #{Auth.minimum_password_length} characters",
+          validates_length_of :unencrypted_secret, :minimum => config.minimum_password_length,
+                              :message => "must be at least #{config.minimum_password_length} characters",
                               :if => :secret_changed?
-          validates_format_of :unencrypted_secret, :with => Auth.password_format, :allow_blank => true,
-                       :message => Auth.password_format_message,
+          validates_format_of :unencrypted_secret, :with => config.password_format, :allow_blank => true,
+                       :message => config.password_format_message,
                        :if => :secret_changed?
                                           
           validates_presence_of :secret
@@ -34,16 +39,21 @@ module Auth
           validates_presence_of :persistence_token
           validates_uniqueness_of :persistence_token, :if => :persistence_token_changed?
           attr_protected :secret, :secret_confirmation
-          
           include Auth::Behavior::Core::PasswordMethods
           
           validate do |password|
             password.errors.rename_attribute("unencrypted_secret", "secret")
           end
+          
+          if Rails::VERSION::MAJOR == 3
+            # The hooks have changed.
+            after_initialize :after_initialize
+          end
         end
       end
       
-      def apply_to_accounts(model_config)
+      def apply_to_user(model)
+        model_config = model.sparkly_config
         model_config.target.instance_eval do
           has_many :passwords, :dependent => :destroy, :as => :authenticatable, :autosave => true
           
@@ -54,11 +64,9 @@ module Auth
   
           include Auth::Behavior::Core::AuthenticatedModelMethods
   
-          after_save do |record|
-            # clear out old passwords so we're conforming to Auth.password_history_length
-            while record.passwords.length > Auth.password_history_length
-              record.passwords.shift.destroy
-            end
+          if Rails::VERSION::MAJOR == 3
+            # The hooks have changed.
+            after_save :after_save
           end
 
           validate do |account|
@@ -67,14 +75,14 @@ module Auth
 
             # the various salts make it impossible to do this:
             #   validates_uniqueness_of :secret, :scope => [ :authenticatable_type, :authenticatable_id ],
-            #                           :message => Auth.password_uniqueness_message
+            #                           :message => config.password_uniqueness_message
             # so we have to do it programmatically.
             if account.password_changed?
               secret = account.password_model.unencrypted_secret
               account.passwords.each do |password|
                 unless password.new_record? # unless it's the one we're creating
                   if password.matches?(secret)
-                    account.errors.add(:password, Auth.password_uniqueness_message)
+                    account.errors.add(:password, sparkly_config.password_uniqueness_message)
                   end
                 end
               end

data/lib/auth/behavior/core/authenticated_model_methods.rb

@@ -43,10 +43,18 @@ module Auth::Behavior::Core::AuthenticatedModelMethods
   
   def after_save
     @new_password = nil
+    # clear out old passwords so we're conforming to sparkly_config.password_history_length
+    while passwords.length > sparkly_config.password_history_length
+      passwords.shift.destroy
+    end
   end
   
   private
   def new_password
-    @new_password ||= returning(Password.new) { |p| passwords << p }
+    @new_password ||= begin
+      p = Password.new
+      passwords << p
+      p
+    end
   end
 end

data/lib/auth/behavior/core/controller_extensions.rb

@@ -1,6 +1,6 @@
 module Auth::Behavior::Core::ControllerExtensions
   def self.included(base)
-    base.instance_eval do
+    base.class_eval do
       include Auth::Behavior::Core::ControllerExtensions::CurrentUser
       extend Auth::Behavior::Core::ControllerExtensions::ClassMethods
       helper_method :new_session_path, :current_user
@@ -18,7 +18,7 @@ module Auth::Behavior::Core::ControllerExtensions
     end
   end
   
-  def store_location(url = request.request_uri)
+  def store_location(url = request.respond_to?(:fullpath) ? request.fullpath : request.request_uri)
     session[:destination] = url
   end
   

data/lib/auth/behavior/core/controller_extensions/class_methods.rb

@@ -21,4 +21,4 @@ module Auth::Behavior::Core::ControllerExtensions::ClassMethods
   alias_method :requires_logout,  :require_logout
   alias_method :require_no_user,  :require_logout
   alias_method :requires_no_user, :require_logout
-end
+end

data/lib/auth/behavior/core/password_methods.rb

@@ -47,11 +47,11 @@ module Auth::Behavior::Core::PasswordMethods
   def secret_with_encryption=(phrase)
     @unencrypted_secret = phrase
     encrypted_phrase = phrase.blank? ? phrase : encrypt(phrase)
-    returning self.secret_without_encryption = encrypted_phrase do
-      reset_persistence_token
-      reset_single_access_token unless single_access_token # don't reset after it has a value
-      reset_perishable_token
-    end
+    self.secret_without_encryption = encrypted_phrase
+    reset_persistence_token
+    reset_single_access_token unless single_access_token # don't reset after it has a value
+    reset_perishable_token
+    return encrypted_phrase
   end
   
   def secret_confirmation_with_encryption=(phrase)

data/lib/auth/behavior/remember_me.rb

@@ -3,12 +3,16 @@ module Auth
     class RememberMe < Auth::Behavior::Base
       migration "create_sparkly_remembered_tokens"
       
-      def apply_to_passwords(password)
+      def apply_to_controller(base_controller, user_model)
+        ApplicationController.send(:include, Auth::Behavior::RememberMe::ControllerExtensions)
+      end
+
+      def apply_to_password(password_model, user_model)
         # no effect
       end
       
-      def apply_to_accounts(model_config)
-        model_config.target.instance_eval do
+      def apply_to_user(user_model)
+        user_model.auth_config.target.instance_eval do
           has_many :remembrance_tokens, :dependent => :destroy, :as => :authenticatable
         end
       end