simple_auth 1.1.0 → 1.2.0

data/Gemfile.lock

@@ -36,12 +36,16 @@ GEM
     activesupport (3.0.3)
     archive-tar-minitar (0.5.2)
     arel (2.0.8)
+    bson (1.2.0)
+    bson_ext (1.2.0)
     builder (2.1.2)
     columnize (0.3.2)
     diff-lcs (1.1.2)
     erubis (2.6.6)
       abstract (>= 1.0.0)
     i18n (0.5.0)
+    jnunemaker-validatable (1.8.4)
+      activesupport (>= 2.3.4)
     linecache19 (0.5.11)
       ruby_core_source (>= 0.1.4)
     mail (2.2.15)
@@ -50,6 +54,14 @@ GEM
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
     mime-types (1.16)
+    mongo (1.2.0)
+      bson (>= 1.2.0)
+    mongo_mapper (0.8.6)
+      activesupport (>= 2.3.4)
+      jnunemaker-validatable (~> 1.8.4)
+      plucky (~> 0.3.6)
+    plucky (0.3.6)
+      mongo (~> 1.1)
     polyglot (0.3.1)
     rack (1.2.1)
     rack-mount (0.6.13)
@@ -105,6 +117,8 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  bson_ext
+  mongo_mapper (~> 0.8.6)
   rspec-rails (~> 2.5.0)
   ruby-debug19
   simple_auth!

data/README.markdown

@@ -140,6 +140,18 @@ If you're having problems to use any helper, include the module `SimpleAuth::Hel
 	  include SimpleAuth::Helper
 	end
 
+### MongoMapper support
+
+You can use SimpleAuth with MongoMapper. Just include the module `SimpleAuth::Orm::MongoMapper` and
+set up your model with the `authentication` macro.
+
+	class User
+	  include MongoMapper::Document
+	  include SimpleAuth::Orm::MongoMapper
+
+	  authentication
+	end
+
 ### Translations
 
 These are the translations you'll need:

data/lib/simple_auth.rb

@@ -2,11 +2,15 @@ require "digest/sha2"
 require "simple_auth/railtie"
 require "simple_auth/config"
 require "simple_auth/action_controller"
-require "simple_auth/active_record"
+require "simple_auth/orm/base"
+require "simple_auth/orm/active_record"
+require "simple_auth/orm/mongo_mapper"
 require "simple_auth/session"
 require "simple_auth/helper"
 require "simple_auth/version"
 
 module SimpleAuth
-  class NotAuthorized < Exception; end
+  class RecordNotFound < StandardError; end
+  class NotAuthorized < StandardError; end
+  class AbstractMethodError < StandardError; end
 end

data/lib/simple_auth/orm/active_record.rb

@@ -0,0 +1,85 @@
+module SimpleAuth
+  module Orm
+    module ActiveRecord
+      def self.included(base)
+        base.class_eval { extend Macro }
+      end
+
+      module Macro
+        # Set virtual attributes, callbacks and validations.
+        # Is called automatically after setting up configuration with
+        # `SimpleAuth.setup {|config| config.model = :user}`.
+        #
+        #   class User < ActiveRecord::Base
+        #     authentication
+        #   end
+        #
+        # Can set configuration when a block is provided.
+        #
+        #   class User < ActiveRecord::Base
+        #     authentication do |config|
+        #       config.credentials = ["email"]
+        #     end
+        #   end
+        #
+        def authentication(&block)
+          SimpleAuth.setup(&block) if block_given?
+          SimpleAuth::Config.model ||= name.underscore.to_sym
+
+          return if respond_to?(:authenticate)
+
+          attr_reader :password
+          attr_accessor :password_confirmation
+
+          include SimpleAuth::Orm::Base::InstanceMethods
+          extend  SimpleAuth::Orm::Base::ClassMethods
+          extend  SimpleAuth::Orm::ActiveRecord::ClassMethods
+
+          before_save :encrypt_password, :if => :validate_password?
+          after_save  :erase_password
+
+          validates_presence_of     :password,              :if => :validate_password?
+          validates_length_of       :password,              :if => :validate_password?, :minimum => 4, :allow_blank => true
+          validates_presence_of     :password_confirmation, :if => :validate_password?
+          validates_confirmation_of :password,              :if => :validate_password?
+        end
+      end
+
+      module ClassMethods
+        # Find user by its credential.
+        #
+        #   User.find_by_credential "john@doe.com" # using e-mail
+        #   User.find_by_credential "john" # using username
+        #
+        def find_by_credential(credential)
+          # Build a hash that will be passed to the finder
+          options = {:conditions => [[], {}]}
+
+          # Iterate each attribute that should be used as credential
+          # and set it to the finder conditions hash
+          SimpleAuth::Config.credentials.each do |attr_name|
+            options[:conditions][0] << "#{attr_name} = :#{attr_name}"
+            options[:conditions][1][attr_name] = credential
+          end
+
+          # Join the attributes in OR query
+          options[:conditions][0] = options[:conditions][0].join(" OR ")
+
+          # Find the record using the conditions we built
+          SimpleAuth::Config.model_class.first(options)
+        end
+
+        # Find user by its credential. If no user is found, raise
+        # SimpleAuth::RecordNotFound exception.
+        #
+        #   User.find_by_credential! "john@doe.com"
+        #
+        def find_by_credential!(credential)
+          record = find_by_credential(credential)
+          raise SimpleAuth::RecordNotFound, "couldn't find #{SimpleAuth::Config.model} using #{credential.inspect} as credential" unless record
+          record
+        end
+      end
+    end
+  end
+end

data/lib/simple_auth/orm/base.rb

@@ -0,0 +1,78 @@
+module SimpleAuth
+  module Orm
+    module Base
+      module InstanceMethods
+        def password=(password)
+          @password_changed = true
+          @password = password
+        end
+
+        def password_changed?
+          @password_changed == true
+        end
+
+        def authorized?
+          true
+        end
+
+        private
+        def encrypt_password
+          self.password_salt = SimpleAuth::Config.salt.call(self)
+          self.password_hash = SimpleAuth::Config.crypter.call(password, password_salt)
+        end
+
+        def erase_password
+          self.password = nil
+          self.password_confirmation = nil
+
+          # Mark password as unchanged after erasing passwords,
+          # or it will be marked as changed anyway
+          @password_changed = false
+        end
+
+        def validate_password?
+          new_record? || password_changed?
+        end
+      end
+
+      module ClassMethods
+        # Find user by its credential.
+        #
+        #   User.find_by_credential "john@doe.com" # using e-mail
+        #   User.find_by_credential "john" # using username
+        #
+        def find_by_credential(credential)
+          raise SimpleAuth::AbstractMethodError
+        end
+
+        # Find user by its credential. If no user is found, raise
+        # SimpleAuth::RecordNotFound exception.
+        #
+        #   User.find_by_credential! "john@doe.com"
+        #
+        def find_by_credential!(credential)
+          raise SimpleAuth::AbstractMethodError
+        end
+
+        # Receive a credential and a password and try to authenticate the specified user.
+        # If the credential is valid, then an user is returned; otherwise nil is returned.
+        #
+        #   User.authenticate "johndoe", "test"
+        #   User.authenticate "john@doe.com", "test"
+        #
+        def authenticate(credential, password)
+          record = find_by_credential(credential)
+
+          # If no record has been found
+          return nil unless record
+
+          # Compare password
+          return nil unless record.password_hash == SimpleAuth::Config.crypter.call(password, record.password_salt)
+
+          # Yay! Everything matched so return record.
+          record
+        end
+      end
+    end
+  end
+end

data/lib/simple_auth/orm/mongo_mapper.rb

@@ -0,0 +1,62 @@
+module SimpleAuth
+  module Orm
+    module MongoMapper
+      def self.included(base)
+        base.class_eval { extend Macro }
+      end
+
+      module Macro
+        def authentication(&block)
+          SimpleAuth.setup(&block) if block_given?
+          SimpleAuth::Config.model ||= name.underscore.to_sym
+
+          return if respond_to?(:authenticate)
+
+          include SimpleAuth::Orm::Base::InstanceMethods
+          extend  SimpleAuth::Orm::Base::ClassMethods
+          extend  SimpleAuth::Orm::MongoMapper::ClassMethods
+
+          attr_reader :password
+          attr_accessor :password_confirmation
+
+          before_save :encrypt_password, :if => :validate_password?
+          after_save  :erase_password
+
+          validates_presence_of     :password,              :if => :validate_password?
+          validates_length_of       :password,              :if => :validate_password?, :minimum => 4, :allow_blank => true
+          validates_presence_of     :password_confirmation, :if => :validate_password?
+          validates_confirmation_of :password,              :if => :validate_password?
+
+          key :password_salt, String
+          key :password_hash, String
+        end
+      end
+
+      module ClassMethods
+        # Find user by its credential.
+        #
+        #   User.find_by_credential "john@doe.com" # using e-mail
+        #   User.find_by_credential "john" # using username
+        #
+        def find_by_credential(credential)
+          conditions = SimpleAuth::Config.credentials.collect do |attr_name|
+            {attr_name => credential}
+          end
+
+          SimpleAuth::Config.model_class.where("$or" => conditions).first
+        end
+
+        # Find user by its credential. If no user is found, raise
+        # SimpleAuth::RecordNotFound exception.
+        #
+        #   User.find_by_credential! "john@doe.com"
+        #
+        def find_by_credential!(credential)
+          record = find_by_credential(credential)
+          raise SimpleAuth::RecordNotFound, "couldn't find #{SimpleAuth::Config.model} using #{credential.inspect} as credential" unless record
+          record
+        end
+      end
+    end
+  end
+end

data/lib/simple_auth/railtie.rb

@@ -12,11 +12,7 @@ module SimpleAuth
         helper_method :current_user, :current_session, :logged_in?
       end
 
-      ::ActiveRecord::Base.instance_eval do
-        include SimpleAuth::ActiveRecord
-      end
-
-      ::I18n.load_path += Dir[File.dirname(__FILE__) + "/../../config/locales/*.yml"]
+      ::ActiveRecord::Base.class_eval { include SimpleAuth::Orm::ActiveRecord } if defined?(::ActiveRecord)
     end
   end
 end

data/lib/simple_auth/version.rb

@@ -1,7 +1,7 @@
 module SimpleAuth
   module Version
     MAJOR = "1"
-    MINOR = "1"
+    MINOR = "2"
     PATCH = "0"
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end

data/simple_auth.gemspec

@@ -20,5 +20,7 @@ Gem::Specification.new do |s|
   s.add_dependency "rails", "~> 3.0.0"
   s.add_development_dependency "sqlite3-ruby"
   s.add_development_dependency "rspec-rails", "~> 2.5.0"
+  s.add_development_dependency "mongo_mapper", "~> 0.8.6"
+  s.add_development_dependency "bson_ext"
   s.add_development_dependency "ruby-debug19"
 end

data/spec/schema.rb

@@ -2,8 +2,4 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table :users do |t|
     t.string :email, :login, :password_hash, :password_salt, :username
   end
-
-  create_table :accounts do |t|
-    t.string :email, :login, :password_hash, :password_salt, :username
-  end
 end

data/spec/simple_auth/active_record_spec.rb

@@ -1,140 +1,9 @@
 require "spec_helper"
 
-describe SimpleAuth::ActiveRecord do
-  subject { User.new }
+describe SimpleAuth::Orm::ActiveRecord do
+  let(:model) { User }
+  let(:model_name) { :user }
+  subject { model.new }
 
-  context "configuration" do
-    it "should set credentials" do
-      User.authentication do |config|
-        config.credentials = ["uid"]
-      end
-
-      SimpleAuth::Config.credentials.should == ["uid"]
-    end
-
-    it "should automatically set model" do
-      User.authentication do |config|
-        config.model = nil
-      end
-
-      SimpleAuth::Config.model.should == :user
-    end
-  end
-
-  context "new record" do
-    before do
-      subject.should_not be_valid
-    end
-
-    it "should require password" do
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should require password to be at least 4-chars long" do
-      subject.password = "123"
-      subject.should_not be_valid
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should require password confirmation not to be empty" do
-      subject.password_confirmation = ""
-      subject.errors[:password_confirmation].should_not be_empty
-    end
-
-    it "should require password confirmation not to be nil" do
-      subject.password_confirmation = nil
-      subject.errors[:password_confirmation].should_not be_empty
-    end
-
-    it "should unset password after saving" do
-      subject = User.new(:password => "test", :password_confirmation => "test")
-      subject.save
-      subject.password.should be_nil
-      subject.password_confirmation.should be_nil
-    end
-
-    it "should mark password as changed" do
-      subject = User.new(:password => "test")
-      subject.password_changed?.should be_true
-    end
-
-    it "should not mark password as changed" do
-      subject = User.new
-      subject.password_changed?.should be_false
-    end
-
-    it "should mark password as unchanged after saving" do
-      subject = User.new(:password => "test", :password_confirmation => "test")
-      subject.save
-      subject.password_changed?.should be_false
-    end
-  end
-
-  context "existing record" do
-    before do
-      User.delete_all
-      User.create(
-        :email => "john@doe.com",
-        :login => "johndoe",
-        :password => "test",
-        :password_confirmation => "test",
-        :username => "john"
-      )
-    end
-
-    subject { User.first }
-
-    it "should not require password when it hasn't changed" do
-      subject.login = "john"
-      subject.should be_valid
-    end
-
-    it "should require password confirmation when it has changed" do
-      subject.password = "newpass"
-      subject.should_not be_valid
-      subject.errors[:password_confirmation].should_not be_empty
-    end
-
-    it "should require password when it has changed to blank" do
-      subject.password = nil
-      subject.should_not be_valid
-      subject.errors[:password].should_not be_empty
-    end
-
-    it "should authenticate using email" do
-      User.authenticate("john@doe.com", "test").should == subject
-    end
-
-    it "should authenticate using login" do
-      User.authenticate("johndoe", "test").should == subject
-    end
-
-    it "should authenticate using custom attribute" do
-      SimpleAuth::Config.credentials = [:username]
-      User.authenticate("john", "test").should == subject
-    end
-
-    it "should not authenticate using invalid credential" do
-      User.authenticate("invalid", "test").should be_nil
-    end
-
-    it "should not authenticate using wrong password" do
-      User.authenticate("johndoe", "invalid").should be_nil
-    end
-
-    it "should return nil when no user has been found" do
-      User.find_by_credential("invalid").should be_nil
-    end
-
-    it "should raise error when no user has been found" do
-      expect {
-        User.find_by_credential!("invalid")
-      }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "should return user" do
-      User.find_by_credential(subject.email).should == subject
-      User.find_by_credential!(subject.email).should == subject
-    end
-  end
+  it_should_behave_like "orm"
 end

data/spec/simple_auth/config_spec.rb

@@ -7,12 +7,6 @@ describe SimpleAuth::Config do
     end
   end
 
-  context "injecting behavior" do
-    it "should not respond to helper methods" do
-      Account.should_not respond_to(:authenticate)
-    end
-  end
-
   it "should use [:email, :login] as credential attributes" do
     SimpleAuth::Config.credentials.should == [:email, :login]
   end

data/spec/simple_auth/mongo_mapper_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe SimpleAuth::Orm::MongoMapper do
+  let(:model) { Account }
+  let(:model_name) { :account }
+  subject { model.new }
+  before { model.delete_all }
+
+  it_should_behave_like "orm"
+end

data/spec/spec_helper.rb

@@ -3,16 +3,161 @@ require "rails"
 require "simple_auth"
 require File.dirname(__FILE__) + "/support/config/boot"
 require "rspec/rails"
+require "mongo_mapper"
 
 # Load database schema
 load File.dirname(__FILE__) + "/schema.rb"
 
+# Set up MongoDB connection
+MongoMapper.connection = Mongo::Connection.new("localhost")
+MongoMapper.database = "simple_auth"
+
 I18n.load_path += Dir[File.dirname(__FILE__) + "/../locales/*.yml"]
 
 # Restore default configuration
 RSpec.configure do |config|
   config.before :each do
     load File.dirname(__FILE__) + "/../lib/simple_auth/config.rb"
-    SimpleAuth::Config.model = :user
+  end
+end
+
+shared_examples_for "orm" do
+  before do
+    SimpleAuth::Config.model = model_name
+  end
+
+  context "configuration" do
+    it "should set credentials" do
+      model.authentication do |config|
+        config.credentials = ["uid"]
+      end
+
+      SimpleAuth::Config.credentials.should == ["uid"]
+    end
+
+    it "should automatically set model" do
+      model.authentication do |config|
+        config.model = nil
+      end
+
+      SimpleAuth::Config.model.should == model_name
+    end
+  end
+
+  context "new record" do
+    before do
+      subject.should_not be_valid
+    end
+
+    it "should require password" do
+      subject.errors[:password].should_not be_empty
+    end
+
+    it "should require password to be at least 4-chars long" do
+      subject.password = "123"
+      subject.should_not be_valid
+      subject.errors[:password].should_not be_empty
+    end
+
+    it "should require password confirmation not to be empty" do
+      subject.password_confirmation = ""
+      subject.errors[:password_confirmation].should_not be_empty
+    end
+
+    it "should require password confirmation not to be nil" do
+      subject.password_confirmation = nil
+      subject.errors[:password_confirmation].should_not be_empty
+    end
+
+    it "should unset password after saving" do
+      subject = model.new(:password => "test", :password_confirmation => "test")
+      subject.save
+      subject.password.should be_nil
+      subject.password_confirmation.should be_nil
+    end
+
+    it "should mark password as changed" do
+      subject = model.new(:password => "test")
+      subject.password_changed?.should be_true
+    end
+
+    it "should not mark password as changed" do
+      subject = model.new
+      subject.password_changed?.should be_false
+    end
+
+    it "should mark password as unchanged after saving" do
+      subject = model.new(:password => "test", :password_confirmation => "test")
+      subject.save
+      subject.password_changed?.should be_false
+    end
+  end
+
+  context "existing record" do
+    before do
+      model.delete_all
+      model.create(
+        :email => "john@doe.com",
+        :login => "johndoe",
+        :password => "test",
+        :password_confirmation => "test",
+        :username => "john"
+      )
+    end
+
+    subject { model.first }
+
+    it "should not require password when it hasn't changed" do
+      subject.login = "john"
+      subject.should be_valid
+    end
+
+    it "should require password confirmation when it has changed" do
+      subject.password = "newpass"
+      subject.should_not be_valid
+      subject.errors[:password_confirmation].should_not be_empty
+    end
+
+    it "should require password when it has changed to blank" do
+      subject.password = nil
+      subject.should_not be_valid
+      subject.errors[:password].should_not be_empty
+    end
+
+    it "should authenticate using email" do
+      model.authenticate("john@doe.com", "test").should == subject
+    end
+
+    it "should authenticate using login" do
+      model.authenticate("johndoe", "test").should == subject
+    end
+
+    it "should authenticate using custom attribute" do
+      SimpleAuth::Config.credentials = [:username]
+      model.authenticate("john", "test").should == subject
+    end
+
+    it "should not authenticate using invalid credential" do
+      model.authenticate("invalid", "test").should be_nil
+    end
+
+    it "should not authenticate using wrong password" do
+      model.authenticate("johndoe", "invalid").should be_nil
+    end
+
+    it "should return nil when no user has been found" do
+      model.find_by_credential("invalid").should be_nil
+    end
+
+    it "should raise error when no user has been found" do
+      expect {
+        model.find_by_credential!("invalid")
+      }.to raise_error(SimpleAuth::RecordNotFound)
+    end
+
+    it "should return user" do
+      model.find_by_credential(subject.email).should == subject
+      model.find_by_credential!(subject.email).should == subject
+    end
   end
 end

data/spec/support/app/models/account.rb

@@ -1,2 +1,6 @@
-class Account < ActiveRecord::Base
+class Account
+  include MongoMapper::Document
+  include SimpleAuth::Orm::MongoMapper
+
+  authentication
 end

metadata

@@ -2,7 +2,7 @@
 name: simple_auth
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Nando Vieira
@@ -47,16 +47,38 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: ruby-debug19
+  name: mongo_mapper
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.8.6
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: "0"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
 description: A simple authentication system for Rails apps
 email: 
 - fnando.vieira@gmail.com
@@ -75,10 +97,12 @@ files:
 - Rakefile
 - lib/simple_auth.rb
 - lib/simple_auth/action_controller.rb
-- lib/simple_auth/active_record.rb
 - lib/simple_auth/config.rb
 - lib/simple_auth/generator.rb
 - lib/simple_auth/helper.rb
+- lib/simple_auth/orm/active_record.rb
+- lib/simple_auth/orm/base.rb
+- lib/simple_auth/orm/mongo_mapper.rb
 - lib/simple_auth/railtie.rb
 - lib/simple_auth/session.rb
 - lib/simple_auth/version.rb
@@ -91,6 +115,7 @@ files:
 - spec/simple_auth/active_record_spec.rb
 - spec/simple_auth/config_spec.rb
 - spec/simple_auth/helper_spec.rb
+- spec/simple_auth/mongo_mapper_spec.rb
 - spec/simple_auth/session_spec.rb
 - spec/spec_helper.rb
 - spec/support/app/controllers/application_controller.rb
@@ -137,6 +162,7 @@ test_files:
 - spec/simple_auth/active_record_spec.rb
 - spec/simple_auth/config_spec.rb
 - spec/simple_auth/helper_spec.rb
+- spec/simple_auth/mongo_mapper_spec.rb
 - spec/simple_auth/session_spec.rb
 - spec/spec_helper.rb
 - spec/support/app/controllers/application_controller.rb

data/lib/simple_auth/active_record.rb

@@ -1,135 +0,0 @@
-module SimpleAuth
-  module ActiveRecord
-    def self.included(base)
-      base.class_eval { extend Macro }
-    end
-
-    module Macro
-      # Set virtual attributes, callbacks and validations.
-      # Is called automatically after setting up configuration with
-      # `SimpleAuth.setup {|config| config.model = :user}`.
-      #
-      #   class User < ActiveRecord::Base
-      #     authentication
-      #   end
-      #
-      # Can set configuration when a block is provided.
-      #
-      #   class User < ActiveRecord::Base
-      #     authentication do |config|
-      #       config.credentials = ["email"]
-      #     end
-      #   end
-      #
-      def authentication(&block)
-        SimpleAuth.setup(&block) if block_given?
-        SimpleAuth::Config.model ||= name.underscore.to_sym
-
-        return if respond_to?(:authenticate)
-
-        attr_reader :password
-        attr_accessor :password_confirmation
-
-        include SimpleAuth::ActiveRecord::InstanceMethods
-        extend  SimpleAuth::ActiveRecord::ClassMethods
-
-        before_save :encrypt_password, :if => :validate_password?
-        after_save  :erase_password
-
-        validates_presence_of     :password,              :if => :validate_password?
-        validates_length_of       :password,              :if => :validate_password?, :minimum => 4, :allow_blank => true
-        validates_presence_of     :password_confirmation, :if => :validate_password?
-        validates_confirmation_of :password,              :if => :validate_password?
-      end
-    end
-
-    module InstanceMethods
-      def password=(password)
-        @password_changed = true
-        @password = password
-      end
-
-      def password_changed?
-        @password_changed == true
-      end
-
-      def authorized?
-        true
-      end
-
-      private
-      def encrypt_password
-        self.password_salt = SimpleAuth::Config.salt.call(self)
-        self.password_hash = SimpleAuth::Config.crypter.call(password, password_salt)
-      end
-
-      def erase_password
-        self.password = nil
-        self.password_confirmation = nil
-
-        # Mark password as unchanged after erasing passwords,
-        # or it will be marked as changed anyway
-        @password_changed = false
-      end
-
-      def validate_password?
-        new_record? || password_changed?
-      end
-    end
-
-    module ClassMethods
-      # Find user by its credential.
-      #
-      #   User.find_by_credential "john@doe.com" # using e-mail
-      #   User.find_by_credential "john" # using username
-      #
-      def find_by_credential(credential)
-        # Build a hash that will be passed to the finder
-        options = {:conditions => [[], {}]}
-
-        # Iterate each attribute that should be used as credential
-        # and set it to the finder conditions hash
-        SimpleAuth::Config.credentials.each do |attr_name|
-          options[:conditions][0] << "#{attr_name} = :#{attr_name}"
-          options[:conditions][1][attr_name] = credential
-        end
-
-        # Join the attributes in OR query
-        options[:conditions][0] = options[:conditions][0].join(" OR ")
-
-        # Find the record using the conditions we built
-        SimpleAuth::Config.model_class.first(options)
-      end
-
-      # Find user by its credential. If no user is found, raise
-      # ActiveRecord::RecordNotFound exception.
-      #
-      #   User.find_by_credential! "john@doe.com"
-      #
-      def find_by_credential!(credential)
-        record = find_by_credential(credential)
-        raise ::ActiveRecord::RecordNotFound, "couldn't find #{SimpleAuth::Config.model} using #{credential.inspect} as credential" unless record
-        record
-      end
-
-      # Receive a credential and a password and try to authenticate the specified user.
-      # If the credential is valid, then an user is returned; otherwise nil is returned.
-      #
-      #   User.authenticate "johndoe", "test"
-      #   User.authenticate "john@doe.com", "test"
-      #
-      def authenticate(credential, password)
-        record = find_by_credential(credential)
-
-        # If no record has been found
-        return nil unless record
-
-        # Compare password
-        return nil unless record.password_hash == SimpleAuth::Config.crypter.call(password, record.password_salt)
-
-        # Yay! Everything matched so return record.
-        record
-      end
-    end
-  end
-end