letmein 0.0.4 → 0.0.5

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/letmein.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{letmein}
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Oleg Khabarov"]
-  s.date = %q{2011-03-26}
+  s.date = %q{2011-03-27}
   s.description = %q{minimalistic authentication}
   s.email = %q{oleg@khabarov.ca}
   s.extra_rdoc_files = [

data/lib/letmein.rb

@@ -3,25 +3,41 @@ require 'bcrypt'
 
 module LetMeIn
   
+  mattr_accessor :model, :identifier, :password, :salt
+  
+  def self.initialize(params = {})
+    @@model       = params[:model]      || 'User'
+    @@identifier  = params[:identifier] || 'email'
+    @@password    = params[:password]   || 'password_hash'
+    @@salt        = params[:salt]       || 'password_salt'
+    @@model.constantize.send :include, LetMeIn::Model
+  end
+  
   class Railtie < Rails::Railtie
     config.after_initialize do
-      # Rails loads models on demand. Configuration doesn't set properly unless assosiated model
-      # is already loaded. This will force it.
-      Dir[Rails.root + 'app/models/**/*.rb'].each{|path| require path }
+      LetMeIn.initialize unless LetMeIn.model.present?
     end
   end
   
   class Error < StandardError
   end
   
-  class Configuration
-    attr_accessor :model, :identifier, :password, :salt
-    
-    def initialize
-      @model      = nil
-      @identifier = 'email'
-      @password   = 'password_hash'
-      @salt       = 'password_salt'
+  module Model
+    def self.included(base)
+      base.instance_eval do
+        attr_accessor :password
+        before_save :encrypt_password
+      end
+      base.class_eval do
+        class_eval %Q^
+          def encrypt_password
+            if password.present?
+              self.send("#{LetMeIn.salt}=", BCrypt::Engine.generate_salt)
+              self.send("#{LetMeIn.password}=", BCrypt::Engine.hash_secret(password, self.send(LetMeIn.salt)))
+            end
+          end
+        ^
+      end
     end
   end
   
@@ -32,7 +48,7 @@ module LetMeIn
     
     def initialize(params = { })
       unless params.blank?
-        self.identifier = params[:identifier] || params[LetMeIn.configuration.identifier.to_sym]
+        self.identifier = params[:identifier] || params[LetMeIn.identifier.to_sym]
         self.password   = params[:password]
       end
     end
@@ -60,20 +76,16 @@ module LetMeIn
     # Mapping to the identifier and authenticated object accessor
     def method_missing(method_name, *args)
       case method_name.to_s
-      when LetMeIn.configuration.identifier
-        self.identifier
-      when "#{LetMeIn.configuration.identifier}="
-        self.identifier = args[0]
-      when LetMeIn.configuration.model.underscore
-        self.authenticated_object
-      else
-        super
+        when LetMeIn.identifier       then self.identifier
+        when "#{LetMeIn.identifier}=" then self.identifier = args[0]
+        when LetMeIn.model.underscore then self.authenticated_object
+        else super
       end
     end
     
     def authenticate
-      object = LetMeIn.configuration.model.constantize.send("find_by_#{LetMeIn.configuration.identifier}", self.identifier)
-      self.authenticated_object = if object && object.send(LetMeIn.configuration.password) == BCrypt::Engine.hash_secret(self.password, object.send(LetMeIn.configuration.salt))
+      object = LetMeIn.model.constantize.send("find_by_#{LetMeIn.identifier}", self.identifier)
+      self.authenticated_object = if object && object.send(LetMeIn.password) == BCrypt::Engine.hash_secret(self.password, object.send(LetMeIn.salt))
         object
       else
         errors.add(:base, 'Failed to authenticate')
@@ -85,38 +97,4 @@ module LetMeIn
       nil
     end
   end
-  
-  module Model
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-      def letmein(*args)
-        LetMeIn.configuration.model       = self.to_s
-        LetMeIn.configuration.identifier  = args[0].to_s if args[0]
-        LetMeIn.configuration.password    = args[1].to_s if args[1]
-        LetMeIn.configuration.salt        = args[2].to_s if args[2]
-        
-        attr_accessor :password
-        
-        before_save :encrypt_password
-        
-        class_eval %Q^
-          def encrypt_password
-            if password.present?
-              self.send("#{LetMeIn.configuration.salt}=", BCrypt::Engine.generate_salt)
-              self.send("#{LetMeIn.configuration.password}=", BCrypt::Engine.hash_secret(password, self.send(LetMeIn.configuration.salt)))
-            end
-          end
-        ^
-      end
-    end
-  end
-  
-  def self.configuration
-    @configuration ||= LetMeIn::Configuration.new
-  end
-end
-
-ActiveRecord::Base.send :include, LetMeIn::Model
+end

data/test/letmein_test.rb

@@ -11,7 +11,6 @@ class User < ActiveRecord::Base
   # example values for password info:
   #   pass: $2a$10$0MeSaaE3I7.0FQ5ZDcKPJeD1.FzqkcOZfEKNZ/DNN.w8xOwuFdBCm
   #   salt: $2a$10$0MeSaaE3I7.0FQ5ZDcKPJe
-  letmein :username, :pass_crypt, :pass_salt
 end
 
 class LetMeInTest < Test::Unit::TestCase
@@ -19,11 +18,13 @@ class LetMeInTest < Test::Unit::TestCase
     ActiveRecord::Base.logger
     ActiveRecord::Schema.define(:version => 1) do
       create_table :users do |t|
-        t.column :username,   :string
-        t.column :pass_crypt, :string
-        t.column :pass_salt,  :string
+        t.column :email,          :string
+        t.column :password_hash,  :string
+        t.column :password_salt,  :string
       end
     end
+    LetMeIn.initialize
+    User.create!(:email => 'test@test.test', :password => 'test')
   end
   
   def teardown
@@ -32,56 +33,43 @@ class LetMeInTest < Test::Unit::TestCase
     end
   end
   
-  def test_configuration_defaults
-    assert config = LetMeIn::Configuration.new
-    assert_equal nil,             config.model
-    assert_equal 'email',         config.identifier
-    assert_equal 'password_hash', config.password
-    assert_equal 'password_salt', config.salt
-  end
-  
   def test_configuration_initialization
-    conf = LetMeIn.configuration
-    assert_equal 'User',        conf.model
-    assert_equal 'username',    conf.identifier
-    assert_equal 'pass_crypt',  conf.password
-    assert_equal 'pass_salt',   conf.salt
+    assert_equal 'User',          LetMeIn.model
+    assert_equal 'email',         LetMeIn.identifier
+    assert_equal 'password_hash', LetMeIn.password
+    assert_equal 'password_salt', LetMeIn.salt
   end
   
   def test_model_password_saving
-    user = User.new(:username => 'test', :password => 'test')
-    user.save!
-    user = User.find(user.id)
+    user = User.first
     assert_equal nil, user.password
-    assert_match /.{60}/, user.pass_crypt
-    assert_match /.{29}/, user.pass_salt
+    assert_match /.{60}/, user.password_hash
+    assert_match /.{29}/, user.password_salt
   end
   
   def test_session_initialization
-    session = LetMeIn::Session.new(:username => 'test_user', :password => 'test_pass')
-    assert_equal 'test_user', session.identifier
-    assert_equal 'test_user', session.username
+    session = LetMeIn::Session.new(:email => 'test@test.test', :password => 'test_pass')
+    assert_equal 'test@test.test', session.identifier
+    assert_equal 'test@test.test', session.email
     assert_equal 'test_pass', session.password
     
-    session.username = 'new_user'
-    assert_equal 'new_user', session.identifier
-    assert_equal 'new_user', session.username
+    session.email = 'new_user@test.test'
+    assert_equal 'new_user@test.test', session.identifier
+    assert_equal 'new_user@test.test', session.email
     
     assert_equal nil, session.authenticated_object
     assert_equal nil, session.user
   end
   
   def test_session_authentication
-    user = User.create!(:username => 'test', :password => 'test')
-    session = LetMeIn::Session.create(:username => 'test', :password => 'test')
+    session = LetMeIn::Session.create(:email => User.first.email, :password => 'test')
     assert session.errors.blank?
-    assert_equal user, session.authenticated_object
-    assert_equal user, session.user
+    assert_equal User.first, session.authenticated_object
+    assert_equal User.first, session.user
   end
   
   def test_session_authentication_failure
-    user = User.create!(:username => 'test', :password => 'test')
-    session = LetMeIn::Session.create(:username => 'test', :password => 'bad_pass')
+    session = LetMeIn::Session.create(:email => User.first.email, :password => 'bad_pass')
     assert session.errors.present?
     assert_equal 'Failed to authenticate', session.errors[:base].first
     assert_equal nil, session.authenticated_object
@@ -89,8 +77,7 @@ class LetMeInTest < Test::Unit::TestCase
   end
   
   def test_session_authentication_exception
-    user = User.create!(:username => 'test', :password => 'test')
-    session = LetMeIn::Session.new(:username => 'test', :password => 'bad_pass')
+    session = LetMeIn::Session.new(:email => User.first.email, :password => 'bad_pass')
     begin
       session.save!
     rescue LetMeIn::Error => e

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Oleg Khabarov
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-26 00:00:00 -04:00
+date: 2011-03-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -108,7 +108,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4289054067406348260
+      hash: 2972491954571850709
       segments: 
       - 0
       version: "0"