clearance 0.16.3 → 1.0.0.rc1

data/lib/clearance/session.rb

@@ -1,18 +1,25 @@
 module Clearance
   class Session
-    REMEMBER_TOKEN_COOKIE = "remember_token".freeze
+    REMEMBER_TOKEN_COOKIE = 'remember_token'.freeze
 
     def initialize(env)
       @env = env
     end
 
-    def signed_in?
-      current_user.present?
+    def add_cookie_to_headers(headers)
+      if signed_in?
+        Rack::Utils.set_cookie_header!(
+          headers, REMEMBER_TOKEN_COOKIE,
+          :value => current_user.remember_token,
+          :expires => Clearance.configuration.cookie_expiration.call,
+          :path => '/'
+        )
+      end
     end
 
     def current_user
       @current_user ||= with_remember_token do |token|
-        Clearance.configuration.user_model.find_by_remember_token(token)
+        Clearance.configuration.user_model.find_by_remember_token token
       end
     end
 
@@ -21,35 +28,36 @@ module Clearance
     end
 
     def sign_out
-      current_user.reset_remember_token! if signed_in?
+      if signed_in?
+        current_user.reset_remember_token!
+      end
+
       @current_user = nil
-      cookies.delete(REMEMBER_TOKEN_COOKIE)
+      cookies.delete REMEMBER_TOKEN_COOKIE
     end
 
-    def add_cookie_to_headers(headers)
-      if signed_in?
-        Rack::Utils.set_cookie_header!(headers,
-                                       REMEMBER_TOKEN_COOKIE,
-                                       :value => current_user.remember_token,
-                                       :expires => Clearance.configuration.cookie_expiration.call,
-                                       :path => "/")
-      end
+    def signed_in?
+      current_user.present?
+    end
+
+    def signed_out?
+      ! signed_in?
     end
 
     private
 
-    def with_remember_token
-      if token = remember_token
-        yield token
-      end
+    def cookies
+      @cookies ||= @env['action_dispatch.cookies'] || Rack::Request.new(@env).cookies
     end
 
     def remember_token
       cookies[REMEMBER_TOKEN_COOKIE]
     end
 
-    def cookies
-      @cookies ||= @env['action_dispatch.cookies'] || Rack::Request.new(@env).cookies
+    def with_remember_token
+      if token = remember_token
+        yield token
+      end
     end
   end
 end

data/lib/clearance/testing.rb

@@ -2,9 +2,14 @@ require 'clearance/testing/assertion_error'
 require 'clearance/testing/deny_access_matcher'
 require 'clearance/testing/helpers'
 
-if defined?(Test::Unit::TestCase)
-  Test::Unit::TestCase.extend Clearance::Testing::Matchers
-  class Test::Unit::TestCase
+Clearance.configure do |config|
+  config.password_strategy = Clearance::PasswordStrategies::Fake
+end
+
+if defined?(ActionController::TestCase)
+  ActionController::TestCase.extend Clearance::Testing::Matchers
+
+  class ActionController::TestCase
     include Clearance::Testing::Helpers
   end
 end

data/lib/clearance/testing/assertion_error.rb

@@ -1,11 +1,6 @@
 module Clearance
   module Testing
-    if RUBY_VERSION > "1.9"
-      require 'minitest/unit'
-      AssertionError = MiniTest::Assertion
-    else
-      require 'test/unit/assertionfailederror'
-      AssertionError = Test::Unit::AssertionFailedError
-    end
+    require 'minitest/unit'
+    AssertionError = MiniTest::Assertion
   end
 end

data/lib/clearance/testing/deny_access_matcher.rb

@@ -1,12 +1,6 @@
 module Clearance
   module Testing
     module Matchers
-      # Ensures a controller denied access.
-      #
-      # @example
-      #   it { should deny_access  }
-      #   it { should deny_access(:flash => "Denied access.")  }
-      #   it { should deny_access(:redirect => sign_in_url)  }
       def deny_access(opts = {})
         DenyAccessMatcher.new(self, opts)
       end
@@ -16,11 +10,15 @@ module Clearance
 
         def initialize(context, opts)
           @context = context
-          @flash   = opts[:flash]
-          @url     = opts[:redirect]
+          @flash = opts[:flash]
+          @url = opts[:redirect]
 
-          @failure_message          = ""
-          @negative_failure_message = ""
+          @failure_message = ''
+          @negative_failure_message = ''
+        end
+
+        def description
+          'deny access'
         end
 
         def matches?(controller)
@@ -28,26 +26,20 @@ module Clearance
           sets_the_flash? && redirects_to_url?
         end
 
-        def description
-          "deny access"
-        end
-
         private
 
-        def sets_the_flash?
-          if @flash.blank?
-            true
+        def denied_access_url
+          if @controller.signed_in?
+            '/'
           else
-            if flash_notice_value == @flash
-              @negative_failure_message << "Didn't expect to set the flash to #{@flash}"
-              true
-            else
-              @failure_message << "Expected the flash to be set to #{@flash} but was #{flash_notice_value}"
-              false
-            end
+            @controller.sign_in_url
           end
         end
 
+        def flash_notice
+          @controller.flash[:notice]
+        end
+
         def flash_notice_value
           if flash_notice.respond_to?(:values)
             flash_notice.values.first
@@ -56,12 +48,9 @@ module Clearance
           end
         end
 
-        def flash_notice
-          @controller.flash[:notice]
-        end
-
         def redirects_to_url?
           @url ||= denied_access_url
+
           begin
             @context.send(:assert_redirected_to, @url)
             @negative_failure_message << "Didn't expect to redirect to #{@url}."
@@ -72,11 +61,17 @@ module Clearance
           end
         end
 
-        def denied_access_url
-          if @controller.signed_in?
-            '/'
+        def sets_the_flash?
+          if @flash.blank?
+            true
           else
-            @controller.sign_in_url
+            if flash_notice_value == @flash
+              @negative_failure_message << "Didn't expect to set the flash to #{@flash}"
+              true
+            else
+              @failure_message << "Expected the flash to be set to #{@flash} but was #{flash_notice_value}"
+              false
+            end
           end
         end
       end

data/lib/clearance/testing/helpers.rb

@@ -1,22 +1,21 @@
 module Clearance
   module Testing
     module Helpers
-      def sign_in_as(user)
-        @controller.current_user = user
-        return user
+      def setup_controller_request_and_response
+        super
+        @request.env[:clearance] = Clearance::Session.new(@request.env)
       end
 
       def sign_in
         sign_in_as FactoryGirl.create(:user)
       end
 
-      def sign_out
-        @controller.current_user = nil
+      def sign_in_as(user)
+        @controller.current_user = user
       end
 
-      def setup_controller_request_and_response
-        super
-        @request.env[:clearance] = Clearance::Session.new(@request.env)
+      def sign_out
+        @controller.current_user = nil
       end
     end
   end

data/lib/clearance/user.rb

@@ -4,155 +4,89 @@ module Clearance
   module User
     extend ActiveSupport::Concern
 
-    # Hook for all Clearance::User modules.
-    #
-    # If you need to override parts of Clearance::User,
-    # extend and include à la carte.
-    #
-    # @example
-    #   include Clearance::User::Callbacks
-    #
-    # @see Validations
-    # @see Callbacks
     included do
       attr_accessor :password_changing
       attr_reader :password
 
       include Validations
       include Callbacks
-
-      include (Clearance.configuration.password_strategy || Clearance::PasswordStrategies::SHA1)
+      include (Clearance.configuration.password_strategy ||
+        Clearance::PasswordStrategies::BCrypt)
     end
 
     module ClassMethods
-      # Authenticate with email and password.
-      #
-      # @param [String, String] email and password
-      # @return [User, nil] authenticated user or nil
-      # @example
-      #   User.authenticate("email@example.com", "password")
       def authenticate(email, password)
-        return nil  unless user = find_by_email(email.to_s.downcase)
-        return user if     user.authenticated?(password)
+        if user = find_by_email(email.to_s.downcase)
+          if user.authenticated? password
+            return user
+          end
+        end
       end
     end
 
     module Validations
       extend ActiveSupport::Concern
 
-      # Hook for validations.
-      #
-      # :email must be present, unique, formatted
-      #
-      # If password is required,
-      # :password must be present, confirmed
       included do
-        validates_presence_of     :email, :unless => :email_optional?
-        validates_uniqueness_of   :email, :allow_blank => true
-        validates_format_of       :email, :with => %r{^[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$}i, :allow_blank => true
+        validates_presence_of :email, :unless => :email_optional?
+        validates_uniqueness_of :email, :allow_blank => true
+        validates_format_of :email, :with => %r{^[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#\$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$}i, :allow_blank => true
 
-        validates_presence_of     :password, :unless => :password_optional?
+        validates_presence_of :password, :unless => :password_optional?
       end
     end
 
     module Callbacks
       extend ActiveSupport::Concern
 
-      # Hook for callbacks.
-      #
-      # salt, token, password encryption are handled before_save.
       included do
         before_validation :downcase_email
         before_create :generate_remember_token
       end
     end
 
-    # Set the remember token.
-    #
-    # @deprecated Use {#reset_remember_token!} instead
-    def remember_me!
-      warn "[DEPRECATION] remember_me!: use reset_remember_token! instead"
-      reset_remember_token!
+    def forgot_password!
+      generate_confirmation_token
+      save :validate => false
     end
 
-    # Reset the remember token.
-    #
-    # @example
-    #   user.reset_remember_token!
     def reset_remember_token!
       generate_remember_token
-      save(:validate => false)
-    end
-
-    # Mark my account as forgotten password.
-    #
-    # @example
-    #   user.forgot_password!
-    def forgot_password!
-      generate_confirmation_token
-      save(:validate => false)
+      save :validate => false
     end
 
-    # Update my password.
-    #
-    # @return [true, false] password was updated or not
-    # @example
-    #   user.update_password('new-password')
     def update_password(new_password)
       self.password_changing = true
-      self.password          = new_password
+      self.password = new_password
+
       if valid?
         self.confirmation_token = nil
         generate_remember_token
       end
-      save
-    end
 
-    def password=(unencrypted_password)
-      @password = unencrypted_password
-      encrypt_password
+      save
     end
 
-    protected
+    private
 
-    def generate_random_code(length = 20)
-      if RUBY_VERSION >= '1.9'
-        SecureRandom.hex(length).encode('UTF-8')
-      else
-        SecureRandom.hex(length)
-      end
+    def downcase_email
+      self.email = email.to_s.downcase
     end
 
-    def generate_remember_token
-      self.remember_token = generate_random_code
+    def email_optional?
+      false
     end
 
     def generate_confirmation_token
-      self.confirmation_token = generate_random_code
+      self.confirmation_token = SecureRandom.hex(20).encode('UTF-8')
     end
 
-    # Always false. Override to allow other forms of authentication
-    # (username, facebook, etc).
-    # @return [Boolean] true if the email field be left blank for this user
-    def email_optional?
-      false
+    def generate_remember_token
+      self.remember_token = SecureRandom.hex(20).encode('UTF-8')
     end
 
-    # True if the password has been set and the password is not being
-    # updated and we are not updating the password. Override to allow
-    # other forms of authentication (username, facebook, etc).
-    # @return [Boolean] true if the password field can be left blank for this user
     def password_optional?
       encrypted_password.present? && password.blank? && password_changing.blank?
     end
-
-    def password_required?
-      # warn "[DEPRECATION] password_required?: use !password_optional? instead"
-      !password_optional?
-    end
-
-    def downcase_email
-      self.email = email.to_s.downcase
-    end
   end
 end

data/lib/clearance/version.rb

@@ -1,3 +1,3 @@
 module Clearance
-  VERSION = '0.16.3'
+  VERSION = '1.0.0.rc1'
 end

data/lib/generators/clearance/install/templates/db/migrate/upgrade_clearance_to_diesel.rb

@@ -1,38 +1,36 @@
-class UpgradeClearanceToDiesel < ActiveRecord::Migration
-  def self.up
 <%
-      existing_columns = ActiveRecord::Base.connection.columns(:users).collect { |each| each.name }
-      columns = [
-        [:email,              't.string :email'],
-        [:encrypted_password, 't.string :encrypted_password, :limit => 128'],
-        [:salt,               't.string :salt, :limit => 128'],
-        [:confirmation_token, 't.string :confirmation_token, :limit => 128'],
-        [:remember_token,     't.string :remember_token, :limit => 128']
-      ].delete_if {|c| existing_columns.include?(c.first.to_s)}
+  existing_columns = ActiveRecord::Base.connection.columns(:users).map(&:name)
+  new_columns = {
+    :email => 't.string :email',
+    :encrypted_password => 't.string :encrypted_password, :limit => 128',
+    :confirmation_token => 't.string :confirmation_token, :limit => 128',
+    :remember_token => 't.string :remember_token, :limit => 128'
+  }.reject { |column| existing_columns.include?(column.to_s) }
+-%>
+<%
+  existing_indexes = ActiveRecord::Base.connection.indexes(:users).map(&:name)
+  new_indexes = {
+    :index_users_on_email => 'add_index :users, :email',
+    :index_users_on_remember_token => 'add_index :users, :remember_token'
+  }.reject { |index| existing_indexes.include?(index.to_s) }
 -%>
-    change_table(:users) do |t|
-<% columns.each do |c| -%>
-      <%= c.last %>
+class UpgradeClearanceToDiesel < ActiveRecord::Migration
+  def self.up
+    change_table :users  do |t|
+<% new_columns.values.each do |column| -%>
+      <%= column %>
 <% end -%>
     end
 
-<%
-    existing_indexes = ActiveRecord::Base.connection.indexes(:users)
-    index_names = existing_indexes.collect { |each| each.name }
-    new_indexes = [
-      [:index_users_on_email,                     'add_index :users, :email'],
-      [:index_users_on_remember_token,            'add_index :users, :remember_token']
-    ].delete_if { |each| index_names.include?(each.first.to_s) }
--%>
-<% new_indexes.each do |each| -%>
-    <%= each.last %>
+<% new_indexes.values.each do |index| -%>
+    <%= index %>
 <% end -%>
   end
 
   def self.down
-    change_table(:users) do |t|
-<% unless columns.empty? -%>
-      t.remove <%= columns.collect { |each| ":#{each.first}" }.join(',') %>
+    change_table :users do |t|
+<% if new_columns.any? -%>
+      t.remove <%= new_columns.keys.map { |column| ":#{column}" }.join(',') %>
 <% end -%>
     end
   end