letmein 0.0.8 → 0.1.0

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.1.0

data/letmein.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{letmein}
-  s.version = "0.0.8"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Oleg Khabarov"]

data/lib/letmein.rb

@@ -7,25 +7,50 @@ module LetMeIn
   
   class Railtie < Rails::Railtie
     config.to_prepare do
-      LetMeIn.initialize unless LetMeIn.models.present?
+      LetMeIn.initialize
     end
   end
   
-  mattr_accessor :models, :identifiers, :passwords, :salts
-  def self.initialize(params = {})
-    @@models      = [params[:model]      || 'User'          ].flatten
-    @@identifiers = [params[:identifier] || 'email'         ].flatten
-    @@passwords   = [params[:password]   || 'password_hash' ].flatten
-    @@salts       = [params[:salt]       || 'password_salt' ].flatten
+  # Configuration class with some defaults. Can be changed like this:
+  #   LetMeIn.configure do |conf|
+  #     conf.model      = 'Account'
+  #     conf.identifier = 'username'
+  #   end
+  class Config
+    ACCESSORS = %w(models identifiers passwords salts)
+    attr_accessor *ACCESSORS
+    def initialize
+      @models       = ['User']
+      @identifiers  = ['email']
+      @passwords    = ['password_hash']
+      @salts        = ['password_salt']
+    end
+    ACCESSORS.each do |a|
+      define_method("#{a.singularize}=") do |val|
+        send("#{a}=", [val].flatten)
+      end
+    end
+  end
+  
+  def self.config
+    @config ||= Config.new
+  end
+  
+  def self.configure
+    yield config
+  end
+  
+  def self.initialize
     
     def self.accessor(name, index = 0)
       name = name.to_s.pluralize
-      self.send(name)[index] || self.send(name)[0]
+      self.config.send(name)[index] || self.config.send(name)[0]
     end
     
-    @@models.each do |model|
+    self.config.models.each do |model|
+      klass = model.constantize rescue next
       
-      model.constantize.send :include, LetMeIn::Model
+      klass.send :include, LetMeIn::Model
       
       Object.const_set("#{model.to_s.camelize}Session", Class.new do
         include ActiveModel::Validations
@@ -34,7 +59,7 @@ module LetMeIn
         
         def initialize(params = { })
           unless params.blank?
-            i = LetMeIn.accessor(:identifier, LetMeIn.models.index(self.class.to_s.gsub('Session','')))
+            i = LetMeIn.accessor(:identifier, LetMeIn.config.models.index(self.class.to_s.gsub('Session','')))
             self.identifier = params[:identifier] || params[i.to_sym]
             self.password   = params[:password]
           end
@@ -58,7 +83,7 @@ module LetMeIn
         
         def method_missing(method_name, *args)
           m = self.class.to_s.gsub('Session','')
-          i = LetMeIn.accessor(:identifier, LetMeIn.models.index(m))
+          i = LetMeIn.accessor(:identifier, LetMeIn.config.models.index(m))
           case method_name.to_s
             when i            then self.identifier
             when "#{i}="      then self.identifier = args[0]
@@ -69,9 +94,9 @@ module LetMeIn
         
         def authenticate
           m = self.class.to_s.gsub('Session','')
-          i = LetMeIn.accessor(:identifier, LetMeIn.models.index(m))
-          p = LetMeIn.accessor(:password, LetMeIn.models.index(m))
-          s = LetMeIn.accessor(:password, LetMeIn.models.index(m))
+          i = LetMeIn.accessor(:identifier, LetMeIn.config.models.index(m))
+          p = LetMeIn.accessor(:password, LetMeIn.config.models.index(m))
+          s = LetMeIn.accessor(:password, LetMeIn.config.models.index(m))
           object = m.constantize.send("find_by_#{i}", self.identifier)
           self.authenticated_object = if object && object.send(p) == BCrypt::Engine.hash_secret(self.password, object.send(s))
             object
@@ -96,8 +121,8 @@ module LetMeIn
         
         define_method :encrypt_password do
           if password.present?
-            p = LetMeIn.accessor(:password, LetMeIn.models.index(self.class.to_s))
-            s = LetMeIn.accessor(:salt, LetMeIn.models.index(self.class.to_s))
+            p = LetMeIn.accessor(:password, LetMeIn.config.models.index(self.class.to_s))
+            s = LetMeIn.accessor(:salt, LetMeIn.config.models.index(self.class.to_s))
             self.send("#{s}=", BCrypt::Engine.generate_salt)
             self.send("#{p}=", BCrypt::Engine.hash_secret(password, self.send(s)))
           end

data/test/letmein_test.rb

@@ -25,50 +25,85 @@ class LetMeInTest < Test::Unit::TestCase
         t.column :pass_salt,  :string
       end
     end
-    LetMeIn.initialize(
-      :model      => ['User', 'Admin'],
-      :identifier => ['email', 'username'],
-      :password   => ['password_hash', 'pass_hash'],
-      :salt       => ['password_salt', 'pass_salt']
-    )
-    User.create!(:email => 'test@test.test', :password => 'test')
-    Admin.create!(:username => 'admin', :password => 'test')
+    init_default_configuration
+  end
+  
+  def init_default_configuration
+    remove_session_classes
+    LetMeIn.configure do |c|
+      c.models      = ['User']
+      c.identifiers = ['email']
+      c.passwords   = ['password_hash']
+      c.salts       = ['password_salt']
+    end
+    LetMeIn.initialize
+  end
+  
+  def init_custom_configuration
+    remove_session_classes
+    LetMeIn.configure do |c|
+      c.models      = ['User', 'Admin']
+      c.identifiers = ['email', 'username']
+      c.passwords   = ['password_hash', 'pass_hash']
+      c.salts       = ['password_salt', 'pass_salt']
+    end
+    LetMeIn.initialize
+  end
+  
+  def remove_session_classes
+    Object.send(:remove_const, :UserSession)  rescue nil
+    Object.send(:remove_const, :AdminSession) rescue nil
   end
   
   def teardown
     ActiveRecord::Base.connection.tables.each do |table|
       ActiveRecord::Base.connection.drop_table(table)
     end
-    Object.send(:remove_const, :UserSession)
-    Object.send(:remove_const, :AdminSession)
+    remove_session_classes
+  end
+  
+  # -- Tests ----------------------------------------------------------------
+  def test_default_configuration_initialization
+    assert_equal ['User'],          LetMeIn.config.models
+    assert_equal ['email'],         LetMeIn.config.identifiers
+    assert_equal ['password_hash'], LetMeIn.config.passwords
+    assert_equal ['password_salt'], LetMeIn.config.salts
   end
   
-  def test_configuration_initialization
-    assert_equal ['User', 'Admin'],               LetMeIn.models
-    assert_equal ['email', 'username'],           LetMeIn.identifiers
-    assert_equal ['password_hash', 'pass_hash'],  LetMeIn.passwords
-    assert_equal ['password_salt', 'pass_salt'],  LetMeIn.salts
+  def test_custom_configuration_initialization
+    LetMeIn.configure do |c|
+      c.model       = 'Account'
+      c.identifier  = 'username'
+      c.password    = 'encrypted_pass'
+      c.salt        = 'salt'
+    end
+    assert_equal ['Account'],         LetMeIn.config.models
+    assert_equal ['username'],        LetMeIn.config.identifiers
+    assert_equal ['encrypted_pass'],  LetMeIn.config.passwords
+    assert_equal ['salt'],            LetMeIn.config.salts
   end
   
-  def test_model_password_saving
-    user = User.first
-    assert_equal nil, user.password
+  def test_model_integration
+    assert User.new.respond_to?(:password)
+    user = User.create!(:email => 'test@test.test', :password => 'pass')
     assert_match /.{60}/, user.password_hash
     assert_match /.{29}/, user.password_salt
   end
   
-  def test_model_password_saving_secondary
-    user = Admin.first
-    assert_equal nil, user.password
+  def test_model_integration_custom
+    init_custom_configuration
+    assert Admin.new.respond_to?(:password)
+    user = Admin.create!(:username => 'test', :password => 'pass')
     assert_match /.{60}/, user.pass_hash
     assert_match /.{29}/, user.pass_salt
   end
   
   def test_session_initialization
-    session = UserSession.new(:email => 'test@test.test', :password => 'test_pass')
+    assert defined?(UserSession)
+    session = UserSession.new(:email => 'test@test.test', :password => 'pass')
     assert_equal 'test@test.test', session.identifier
     assert_equal 'test@test.test', session.email
-    assert_equal 'test_pass', session.password
+    assert_equal 'pass', session.password
     
     session.email = 'new_user@test.test'
     assert_equal 'new_user@test.test', session.identifier
@@ -79,6 +114,8 @@ class LetMeInTest < Test::Unit::TestCase
   end
   
   def test_session_initialization_secondary
+    init_custom_configuration
+    assert defined?(AdminSession)
     session = AdminSession.new(:username => 'admin', :password => 'test_pass')
     assert_equal 'admin', session.identifier
     assert_equal 'admin', session.username
@@ -93,21 +130,25 @@ class LetMeInTest < Test::Unit::TestCase
   end
   
   def test_session_authentication
-    session = UserSession.create(:email => User.first.email, :password => 'test')
+    user = User.create!(:email => 'test@test.test', :password => 'pass')
+    session = UserSession.create(:email => user.email, :password => 'pass')
     assert session.errors.blank?
-    assert_equal User.first, session.authenticated_object
-    assert_equal User.first, session.user
+    assert_equal user, session.authenticated_object
+    assert_equal user, session.user
   end
   
-  def test_session_authentication_secondary
-    session = AdminSession.create(:username => Admin.first.username, :password => 'test')
+  def test_session_authentication_custom
+    init_custom_configuration
+    admin = Admin.create!(:username => 'admin', :password => 'pass')
+    session = AdminSession.create(:username => admin.username, :password => 'pass')
     assert session.errors.blank?
-    assert_equal Admin.first, session.authenticated_object
-    assert_equal Admin.first, session.admin
+    assert_equal admin, session.authenticated_object
+    assert_equal admin, session.admin
   end
   
   def test_session_authentication_failure
-    session = UserSession.create(:email => User.first.email, :password => 'bad_pass')
+    user = User.create!(:email => 'test@test.test', :password => 'pass')
+    session = UserSession.create(:email => user.email, :password => 'bad_pass')
     assert session.errors.present?
     assert_equal 'Failed to authenticate', session.errors[:base].first
     assert_equal nil, session.authenticated_object
@@ -115,7 +156,8 @@ class LetMeInTest < Test::Unit::TestCase
   end
   
   def test_session_authentication_exception
-    session = UserSession.new(:email => User.first.email, :password => 'bad_pass')
+    user = User.create!(:email => 'test@test.test', :password => 'pass')
+    session = UserSession.new(:email => user.email, :password => 'bad_pass')
     begin
       session.save!
     rescue LetMeIn::Error => e

metadata

@@ -2,7 +2,7 @@
 name: letmein
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors: 
 - Oleg Khabarov
@@ -88,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2714324773765342920
+      hash: -3376518755329452587
       segments: 
       - 0
       version: "0"