entrance 0.3.4 → 0.4.0

data/examples/rails-app/app/models/user.rb

@@ -1,5 +1,5 @@
 class User < ActiveRecord::Base
   include Entrance::Model
-  
-  validate_entrance! # ensures everything is in order, and sets up password validations
+
+  provides_entrance
 end

data/examples/sinatra-app/app/models.rb

@@ -28,7 +28,7 @@ class User
   key :reset_token
   key :reset_token_expires_at, Time
 
-  validate_entrance! # ensures everything is in order, and sets up password validations
+  provides_entrance
 
   def active?
     state.to_sym == :active

data/examples/sinatra-app/app/routes.rb

@@ -43,6 +43,8 @@ module Example
     post '/login' do
       if user = User.authenticate(params[:email], params[:password]) and user.active?
         remember = ['on', '1'].include?(params[:remember_me])
+
+        puts user.inspect
         login!(user, remember)
 
         flash[:success] = 'Welcome back!'

data/lib/entrance/config.rb

@@ -20,18 +20,8 @@ module Entrance
       @secret                     = nil
       @stretches                  = 10
 
-      # fields
-      @salt_attr                  = nil
-      @unique_key                 = 'id'
-      @username_attr              = 'email'
-      @password_attr              = 'password_hash'
-      @remember_token_attr        = 'remember_token'
-      @remember_until_attr        = 'remember_token_expires_at'
-      @reset_token_attr           = 'reset_token'
-      @reset_until_attr           = 'reset_token_expires_at'
-
       # access denied
-      @access_denied_redirect_to  = '/'
+      @access_denied_redirect_to  = '/login'
       @access_denied_message_key  = nil # e.g. 'messages.access_denied'
 
       # reset password
@@ -45,11 +35,6 @@ module Entrance
       @cookie_secure              = true
       @cookie_path                = '/'
       @cookie_httponly            = false
-
-      # for omniauth support
-      @name_attr                  = 'name'
-      @auth_provider_attr         = 'auth_provider'
-      @auth_uid_attr              = 'auth_uid'
     end
 
     def validate!

data/lib/entrance/controller.rb

@@ -50,7 +50,7 @@ module Entrance
     # new_user may be nil (when logging out) or an instance of the Entrance.model class
     def current_user=(new_user)
       raise "Invalid user: #{new_user}" unless new_user.nil? or new_user.is_a?(Entrance.model)
-      session[:user_id] = new_user ? new_user.send(Entrance.config.unique_key) : nil
+      session[:user_id] = new_user ? new_user.send(Entrance.fields.unique_key) : nil
       @current_user = new_user # should be nil when logging out
     end
 
@@ -78,7 +78,7 @@ module Entrance
 
     def login_from_session
       query = {}
-      query[Entrance.config.unique_key] = session[:user_id]
+      query[Entrance.fields.unique_key] = session[:user_id]
       self.current_user = Entrance.model.where(query).first if session[:user_id]
     end
 
@@ -86,9 +86,9 @@ module Entrance
       return unless Entrance.config.can?(:remember) && request.cookies[REMEMBER_ME_TOKEN]
 
       query = {}
-      query[Entrance.config.remember_token_attr] = request.cookies[REMEMBER_ME_TOKEN]
+      query[Entrance.fields.remember_token] = request.cookies[REMEMBER_ME_TOKEN]
       if user = Entrance.model.where(query).first \
-        and user.send(Entrance.config.remember_until_attr) > Time.now
+        and user.send(Entrance.fields.remember_until) > Time.now
           self.current_user = user
           # user.update_remember_token_expiration!
           user

data/lib/entrance/fields.rb

@@ -0,0 +1,79 @@
+module Entrance
+
+  class Fields
+
+    attr_accessor *%w(
+      unique_key salt username password
+      remember_token remember_until reset_token reset_until
+      name auth_provider auth_uid
+    )
+
+    def initialize
+      @unique_key            = 'id'
+      @salt                  = nil
+      @username              = 'email'
+      @password              = 'password_hash'
+
+      # remember and reset
+      @remember_token        = 'remember_token'
+      @remember_until        = 'remember_token_expires_at'
+      @reset_token           = 'reset_token'
+      @reset_until           = 'reset_token_expires_at'
+
+      # omniauth
+      @name                  = 'name'
+      @auth_provider         = 'auth_provider'
+      @auth_uid              = 'auth_uid'
+    end
+
+    def validate!
+      raise "Invalid model: #{Entrance.config.model}!" unless Kernel.const_defined?(Entrance.config.model)
+
+      fields = get_model_fields
+
+      %w(username password).each do |attr|
+        field = send(attr)
+        unless fields.include?(field.to_sym)
+          raise "Couldn't find '#{field}' in the #{Entrance.model.name} model."
+        end
+      end
+
+      %w(remember reset).each do |what|
+        if field = send("#{what}_token")
+          until_field = send("#{what}_until")
+
+          unless fields.include?(field.to_sym)
+            raise "No #{field} field found. \
+                   Set the fields.#{what} option to nil to disable the #{what} option."
+          end
+
+          if until_field
+            unless fields.include?(until_field.to_sym)
+              raise "Couldn't find a #{until_field} field. Cannot continue."
+            end
+          else
+            puts "Disabling expiration timestamp for the #{what} option. This is a VERY bad idea."
+          end
+
+          Entrance.config.can?(what, true)
+
+          mod = what.to_sym == :remember ? Entrance::Model::RememberMethods : Entrance::Model::ResetMethods
+          Entrance.model.send(:include, mod)
+        end
+      end
+    end
+
+    def get_model_fields
+      model = Entrance.model
+       if model.respond_to?(:columns)          # ActiveRecord::Base
+        model.columns.collect(&:name)
+      elsif model.respond_to?(:keys)           # MongoMapper::Document
+        model.keys.keys
+      else                                     # just get setters in the class
+        model.instance_methods(false).select { |m| m[/\=$/] }.map { |s| s.to_s.sub('=', '') }
+      end.map { |el| el.to_sym }
+    end
+
+  end
+
+end

data/lib/entrance/model.rb

@@ -2,57 +2,25 @@ module Entrance
   module Model
 
     def self.included(base)
-
-      # if the target model class does not have a Model.where() method,
-      # then login_by_session wont work, nor the ClassMethods below.
-      # won't work so we cannot continue.
-      unless base.respond_to?(:where)
-        raise "#{base.name} does not have a .where() finder class method. Cannot continue."
-      end
-
       base.extend(ClassMethods)
     end
 
     module ClassMethods
 
-      def validate_entrance!
-        fields = if self.respond_to?(:columns)   # ActiveRecord::Base
-          columns.collect(&:name)
-        elsif self.respond_to?(:keys)            # MongoMapper::Document
-          keys.keys
-        else                                     # just get setters in the class
-          instance_methods(false).select { |m| m[/\=$/] }.map { |s| s.to_s.sub('=', '') }
-        end.map { |el| el.to_sym }
-
-        %w(username_attr password_attr).each do |key|
-          field = Entrance.config.send(key)
-          unless fields.include?(field.to_sym)
-            raise "Couldn't find '#{field}' in #{self.name} model."
-          end
-        end
+      def provides_entrance(&block)
+        Entrance.config.model = self.name
 
-        %w(remember reset).each do |what|
-          if field = Entrance.config.send("#{what}_token_attr")
-            until_field = Entrance.config.send("#{what}_until_attr")
-
-            unless fields.include?(field.to_sym)
-              raise "No #{Entrance.config.send("#{what}_token_attr")} field found. \
-                     Set the config.#{what}_token_attr option to nil to disable the #{what} option."
-            end
-
-            if until_field
-              unless fields.include?(until_field.to_sym)
-                raise "Couldn't find a #{Entrance.config.send("#{what}_until_attr")} field. Cannot continue."
-              end
-            else
-              puts "Disabling expiration timestamp for the #{what} option. This is a VERY bad idea."
-            end
-
-            Entrance.config.can?(what, true)
-            self.send(:include, what.to_sym == :remember ? RememberMethods : ResetMethods)
-          end
+        # if the target model class does not have a Model.where() method,
+        # then login_by_session wont work, nor the ClassMethods below.
+        # won't work so we cannot continue.
+        unless self.respond_to?(:where)
+          raise "#{self.name} does not have a .where() finder class method. Cannot continue."
         end
 
+        fields = Entrance.fields
+        yield fields if block_given?
+        fields.validate!
+
         if self.respond_to?(:validates)
           validates :password, :presence => true, :length => 6..32, :if => :password_required?
           validates :password, :confirmation => true, :if => :password_required?
@@ -64,7 +32,7 @@ module Entrance
         return if [username, password].any? { |v| v.nil? || v.strip == '' }
 
         query = {}
-        query[Entrance.config.username_attr] = username.to_s.downcase.strip
+        query[Entrance.fields.username] = username.to_s.downcase.strip
         if u = where(query).first
           return u.authenticated?(password) ? u : nil
         end
@@ -75,9 +43,9 @@ module Entrance
         return if token.nil?
 
         query = {}
-        query[Entrance.config.reset_token_attr] = token.to_s.strip
+        query[Entrance.fields.reset_token] = token.to_s.strip
         if u = where(query).first \
-          and (!Doorman.config.reset_until_attr || u.send(Doorman.config.reset_until_attr) > Time.now)
+          and (!Entrance.fields.reset_until || u.send(Entrance.fields.reset_until) > Time.now)
             return u
         end
       end
@@ -87,10 +55,10 @@ module Entrance
     module ResetMethods
 
       def request_password_reset!
-        send(Entrance.config.reset_token_attr + '=', Entrance.generate_token)
-        if Doorman.config.reset_until_attr
+        send(Entrance.fields.reset_token + '=', Entrance.generate_token)
+        if Entrance.fields.reset_until
           timestamp = Time.now + Entrance.config.reset_password_window
-          update_attribute(Entrance.config.reset_until_attr, timestamp)
+          update_attribute(Entrance.fields.reset_until, timestamp)
         end
         if save(:validate => false)
           method = Entrance.config.reset_password_method
@@ -104,19 +72,19 @@ module Entrance
 
       def remember_me!(until_date = nil)
         token = Entrance.generate_token
-        update_attribute(Entrance.config.remember_token_attr, token) or return
-        update_remember_token_expiration!(until_date) if Entrance.config.remember_until_attr
+        update_attribute(Entrance.fields.remember_token, token) or return
+        update_remember_token_expiration!(until_date) if Entrance.fields.remember_until
         token
       end
 
       def update_remember_token_expiration!(until_date = nil)
         timestamp = Time.now + (until_date || Entrance.config.remember_for).to_i
-        update_attribute(Entrance.config.remember_until_attr, timestamp)
+        update_attribute(Entrance.fields.remember_until, timestamp)
       end
 
       def forget_me!
-        update_attribute(Entrance.config.remember_token_attr, nil)
-        update_attribute(Entrance.config.remember_until_attr, nil) if Entrance.config.remember_until_attr
+        update_attribute(Entrance.fields.remember_token, nil)
+        update_attribute(Entrance.fields.remember_until, nil) if Entrance.fields.remember_until
       end
 
     end
@@ -136,18 +104,18 @@ module Entrance
       @password_changed = true
 
       # if we're using salt and it is empty, generate one
-      if Entrance.config.salt_attr \
-        and send(Entrance.config.salt_attr).nil?
-          self.send(Entrance.config.salt_attr + '=', Entrance.generate_token)
+      if Entrance.fields.salt \
+        and send(Entrance.fields.salt).nil?
+          self.send(Entrance.fields.salt + '=', Entrance.generate_token)
       end
 
-      self.send(Entrance.config.password_attr + '=', encrypt_password(new_password))
+      self.send(Entrance.fields.password + '=', encrypt_password(new_password))
     end
 
     private
 
     def read_password
-      send(Entrance.config.password_attr)
+      send(Entrance.fields.password)
     end
 
     def encrypt_password(string)
@@ -155,7 +123,7 @@ module Entrance
     end
 
     def get_salt
-      Entrance.config.salt_attr && send(Entrance.config.salt_attr)
+      Entrance.fields.salt && send(Entrance.fields.salt)
     end
 
     def password_required?

data/lib/entrance/version.rb

@@ -1,7 +1,7 @@
 module Entrance
   MAJOR = 0
-  MINOR = 3
-  PATCH = 4
+  MINOR = 4
+  PATCH = 0
 
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/lib/entrance.rb

@@ -2,6 +2,7 @@ require 'entrance/controller'
 require 'entrance/model'
 require 'entrance/ciphers'
 require 'entrance/config'
+require 'entrance/fields'
 require 'digest/sha1'
 
 module Entrance
@@ -10,15 +11,19 @@ module Entrance
     @config ||= Config.new
   end
 
+  def self.model
+    @model ||= Kernel.const_get(config.model)
+  end
+
+  def self.fields
+    @fields ||= Fields.new
+  end
+
   def self.configure
     yield config
     config.validate!
   end
 
-  def self.model
-    @model ||= Kernel.const_get(config.model)
-  end
-
   def self.generate_token(length = 40)
     str = Digest::SHA1.hexdigest([Time.now, rand].join)
     str[0..(length-1)]

data/spec/fake_model.rb

@@ -1,15 +1,7 @@
 require 'entrance'
 
 Entrance.configure do |config|
-  config.model         = 'FakeUser'
-  config.unique_key    = 'email'
-  config.username_attr = 'email'
-  config.password_attr = 'password'
 
-  # disabling reset password and remember options
-  config.reset_token_attr    = nil
-  config.remember_token_attr = nil
-  # config.cookie_secure       = false
 
   config.access_denied_redirect_to = '/login'
 end
@@ -18,6 +10,7 @@ end
 # admin user model
 
 class FakeUser
+  include Entrance::Model
   attr_accessor :email, :password #, :remember_token
 
   USERS = {
@@ -47,6 +40,14 @@ class FakeUser
     password == string
   end
 
-  include Entrance::Model # ensure after we declare the .where method
+  provides_entrance do |fields|
+    fields.unique_key  = 'email'
+    fields.username    = 'email'
+    fields.password    = 'password'
+
+    # disabling reset password and remember options
+    fields.reset_token    = nil
+    fields.remember_token = nil
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: entrance
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -117,6 +117,7 @@ files:
 - lib/entrance/ciphers.rb
 - lib/entrance/config.rb
 - lib/entrance/controller.rb
+- lib/entrance/fields.rb
 - lib/entrance/model.rb
 - lib/entrance/version.rb
 - spec/controller_spec.rb