janus 0.6.0 → 0.7.0

data/lib/janus/hooks/rememberable.rb

@@ -1,7 +1,7 @@
 Janus::Manager.after_login do |user, manager, options|
   if options[:rememberable] && user.respond_to?(:remember_me!)
     user.remember_me!
-    
+
     remember_cookie_name = Janus::Strategies::Rememberable.remember_cookie_name(options[:scope])
     manager.cookies[remember_cookie_name] = {
       :value => user.remember_token,
@@ -13,7 +13,7 @@ end
 Janus::Manager.after_logout do |user, manager, options|
   if user.respond_to?(:forget_me!)
     user.forget_me!
-    
+
     remember_cookie_name = Janus::Strategies::Rememberable.remember_cookie_name(options[:scope])
     manager.cookies.delete(remember_cookie_name)
   end

data/lib/janus/hooks/remote_authenticatable.rb

@@ -1,7 +1,7 @@
 Janus::Manager.after_login do |user, manager, options|
   if user.respond_to?(:generate_session_token!)
     user.generate_session_token! if user.session_token.nil?
-    
+
     session = manager.session(options[:scope])
     session[:session_token] = user.session_token
   end

data/lib/janus/manager.rb

@@ -33,7 +33,7 @@ module Janus
     end
 
     # Logs a user in.
-    # 
+    #
     # FIXME: what should happen when a user signs in but a user is already signed in for the same scope?!
     def login(user, options = {})
       options[:scope] ||= Janus.scope_for(user)
@@ -46,13 +46,13 @@ module Janus
     # whole session will be resetted.
     def logout(*scopes)
       scopes = janus_sessions.keys if scopes.empty?
-      
+
       scopes.each do |scope|
         _user = user(scope)
         unset_user(scope)
         Janus::Manager.run_callbacks(:logout, _user, self, :scope => scope)
       end
-      
+
       request.reset_session if janus_sessions.empty?
     end
 
@@ -73,7 +73,7 @@ module Janus
     def user(scope)
       scope = scope.to_sym
       @users ||= {}
-      
+
       if authenticated?(scope)
         if @users[scope].nil?
           begin
@@ -84,7 +84,7 @@ module Janus
             Janus::Manager.run_callbacks(:fetch, @users[scope], self, :scope => scope)
           end
         end
-        
+
         @users[scope]
       end
     end

data/lib/janus/models/base.rb

@@ -17,14 +17,14 @@ module Janus
             def self.#{key}
               @#{key} || Janus::Config.#{key}
             end
-            
+
             def self.#{key}=(value)
               @#{key} = value
             end
             EOV
           end
         end
-        
+
       end
     end
   end

data/lib/janus/models/confirmable.rb

@@ -1,18 +1,21 @@
 module Janus
   module Models
     # = Confirmable
-    # 
+    #
     # Confirms an account's email by sending an email with an unique token.
     # This is necessary to be sure the user can be contacted on that email.
-    # 
+    #
     # IMPROVE: reconfirm whenever email changes.
     module Confirmable
       extend ActiveSupport::Concern
 
       included do
-        attr_protected :confirmation_token, :confirmation_sent_at, :confirmed_at
+        begin
+          attr_protected :confirmation_token, :confirmation_sent_at, :confirmed_at
+        rescue
+        end
         janus_config(:confirmation_key)
-        
+
         before_create :generate_confirmation_token
 #        before_update :generate_confirmation_token, :if => :email_changed?
       end

data/lib/janus/models/database_authenticatable.rb

@@ -1,36 +1,46 @@
-require 'bcrypt'
-require 'scrypt'
+begin
+  require 'bcrypt'
+rescue
+end
+
+begin
+  require 'scrypt'
+rescue
+end
 
 module Janus
   module Models
     # = DatabaseAuthenticatable
-    # 
+    #
     # This is the initial part and is required for email + password registration
     # and logins. Passwords are automatically encrypted following Devise's
     # default encryption logic, which relies on bcrypt.
-    # 
+    #
     # == Required columns:
-    # 
+    #
     # - email
     # - encrypted_password
-    # 
+    #
     # == Configuration
-    # 
+    #
     # - +stretches+
     # - +pepper+
     # - +authentication_keys+ - required keys for authenticating a user, defaults to <tt>[:email]</tt>
-    # 
+    #
     module DatabaseAuthenticatable
       extend ActiveSupport::Concern
 
       included do
-        attr_protected :encrypted_password, :reset_password_token, :reset_password_sent_at
+        begin
+          attr_protected :encrypted_password, :reset_password_token, :reset_password_sent_at
+        rescue
+        end
         attr_reader    :password
         attr_accessor  :current_password
-        
+
         validates :password, :presence => true, :confirmation => true, :if => :password_required?
         validate :validate_current_password, :on => :update, :if => :current_password
-        
+
         janus_config(:authentication_keys, :encryptor, :stretches, :pepper, :scrypt_options)
       end
 
@@ -74,10 +84,10 @@ module Janus
       end
 
       def reset_password!(params)
-        params.each do |key, value|
-          send("#{key}=", value) if [:password, :password_confirmation].include?(key.to_sym)
+        %w{password password_confirmation}.each do |attr|
+          send("#{attr}=", params[attr]) if params.has_key?(attr)
         end
-        
+
         self.reset_password_sent_at = self.reset_password_token = nil
         save
       end
@@ -99,13 +109,13 @@ module Janus
 
         def find_for_password_reset(token)
           user = find_by_reset_password_token(token) unless token.blank?
-          
+
           if user && user.reset_password_sent_at < 2.days.ago
             user.reset_password_token = user.reset_password_sent_at = nil
             user.save
             user = nil
           end
-          
+
           user
         end
       end

data/lib/janus/models/rememberable.rb

@@ -1,26 +1,29 @@
 module Janus
   module Models
     # = Rememberable
-    # 
+    #
     # Allows a user to check a remember me check box when she logs in through
     # DatabaseAuthenticatable. It will set a cookie with a configurable
     # expiration date.
-    # 
+    #
     # == Required columns
-    # 
+    #
     # - remember_token
     # - remember_created_at
-    # 
+    #
     # == Configuration
-    # 
+    #
     # - remember_for - how long to remember the user, for instance <tt>1.week</tt>.
     # - :extend_remember_period - set to true to extend the remember cookie every time the user logs in.
-    # 
+    #
     module Rememberable
       extend ActiveSupport::Concern
 
       included do
-        attr_protected :remember_token, :remember_created_at
+        begin
+          attr_protected :remember_token, :remember_created_at
+        rescue
+        end
         janus_config :remember_for, :extend_remember_period
       end
 
@@ -40,12 +43,12 @@ module Janus
       module ClassMethods
         def find_for_remember_authentication(token)
           user = where(:remember_token => token).first unless token.blank?
-          
+
           if user && user.remember_created_at < remember_for.ago
             user.forget_me!
             user = nil
           end
-          
+
           user
         end
       end

data/lib/janus/models/remote_authenticatable.rb

@@ -3,61 +3,64 @@ require 'janus/hooks/remote_authenticatable'
 module Janus
   module Models
     # = RemoteAuthenticatable
-    # 
+    #
     # Keeping a user connected on subdomains is an easy task, all you need to do
     # is define the session cookie to <tt>.example.com</tt> for instance. But
     # keeping a user connected on multiple top level domains is a harder task.
-    # 
+    #
     # Hopefully RemoteAuthenticatable takes care of all the hassle.
-    # 
+    #
     # == Single Sign In
-    # 
+    #
     # The authentication must happen on a single domain, for instance
     # <tt>login.example.com</tt>, then other domains must redirect to that
     # domain's new session url. For instance:
-    # 
+    #
     #   redirect_to new_user_session_url(:host => "login.example.com") unless user_signed_in?
-    # 
+    #
     # And that's it! The user shall be redirected with an unique +remote_token+,
     # which shall log her in. Actually the user won't be logged in through
     # Janus::Manager#login but through Janus::Manager#set_user which won't
     # run the login hooks. This is useful for not tracking the user everytime
     # it gets authenticated on each remote site.
-    # 
+    #
     # == Single Sign Out
-    # 
+    #
     # Session state is maintained across domains through the session_token
     # column of your User model. If a session token is invalid the session
     # is simply resetted, thus logging out the user on remote domains. Actually
     # the user is logged out using Janus::Manager#unset_user before
     # resetting the session.
-    # 
+    #
     # == Required columns and models:
-    # 
+    #
     # A +session_token+ column (string) is required, as well as a RemoteToken
     # model like so:
-    # 
+    #
     #   class RemoteToken < ActiveRecord::Base
     #     include Janus::Models::RemoteToken
-    #   
+    #
     #     belongs_to :user
     #     validates_presence_of :user
     #   end
-    # 
+    #
     # With the associated table:
-    # 
+    #
     #   create_table :remote_tokens do |t|
     #     t.references :user
     #     t.string     :token
     #     t.datetime   :created_at
     #   end
-    #   
+    #
     #   add_index :remote_tokens, :token, :unique => true
     module RemoteAuthenticatable
       extend ActiveSupport::Concern
 
       included do |klass|
-        attr_protected :session_token
+        begin
+          attr_protected :session_token
+        rescue
+        end
         klass.class_eval { has_many :remote_tokens }
         janus_config :remote_authentication_key
       end
@@ -65,7 +68,7 @@ module Janus
       # Generates an unique session token. This token will be used to validate
       # the current session, and must be generated whenever a user signs in on
       # the main site.
-      # 
+      #
       # The token won't be regenerated if it already exists.
       def generate_session_token!
         update_attribute(:session_token, self.class.generate_token(:session_token)) unless session_token
@@ -87,7 +90,7 @@ module Janus
       module ClassMethods
         def find_for_remote_authentication(token)
           remote_token = ::RemoteToken.where(:token => token).first
-          
+
           if remote_token
             remote_token.destroy
             remote_token.user unless remote_token.created_at < 30.seconds.ago

data/lib/janus/models/trackable.rb

@@ -3,33 +3,36 @@ require 'janus/hooks/trackable'
 module Janus
   module Models
     # = Trackable
-    # 
+    #
     # Simple hook to update some columns of your model whenever a user logs in.
-    # 
+    #
     # == Required columns
-    # 
+    #
     # - +sign_in_count+
     # - +current_sign_in_ip+
     # - +current_sign_in_at+
     # - +last_sign_in_ip+
     # - +last_sign_in_at+
-    # 
+    #
     module Trackable
       extend ActiveSupport::Concern
 
       included do
-        attr_protected :sign_in_count, :current_sign_in_at, :last_sign_in_at, :current_sign_in_ip, :last_sign_in_ip
+        begin
+          attr_protected :sign_in_count, :current_sign_in_at, :last_sign_in_at, :current_sign_in_ip, :last_sign_in_ip
+        rescue
+        end
       end
 
       def track!(ip)
         self.sign_in_count += 1
-        
+
         self.last_sign_in_at = self.current_sign_in_at
         self.last_sign_in_ip = self.current_sign_in_ip
-        
+
         self.current_sign_in_at = Time.now
         self.current_sign_in_ip = ip
-        
+
         save(:validate => false)
       end
     end

data/lib/janus/routes.rb

@@ -2,73 +2,73 @@ module ActionDispatch # :nodoc:
   module Routing # :nodoc:
     class Mapper
       # Creates the routes for a Janus capable resource.
-      # 
+      #
       # Example:
-      # 
+      #
       #   MyApp::Application.routes.draw do
       #     janus :users, :session => true, :registration => false
       #   end
-      # 
+      #
       # Options:
-      # 
+      #
       # - +session+      - true to generate session routes
       # - +registration+ - true to generate registration routes
       # - +confirmation+ - true to generate confirmation routes
       # - +password+     - true to generate password reset routes
-      # 
+      #
       # Generated session routes:
-      # 
+      #
       #       new_user_session GET    /users/sign_in(.:format)  {:controller=>"users/sessions", :action=>"new"}
       #           user_session POST   /users/sign_in(.:format)  {:controller=>"users/sessions", :action=>"create"}
-      #   destroy_user_session        /users/sign_out(.:format) {:controller=>"users/sessions", :action=>"destroy"}
-      # 
+      #   destroy_user_session DELETE /users/sign_out(.:format) {:controller=>"users/sessions", :action=>"destroy"}
+      #
       # Generated registration routes:
-      # 
+      #
       #    new_user_registration GET    /users/sign_up(.:format)  {:controller=>"users/registrations", :action=>"new"}
       #        user_registration POST   /users(.:format)          {:controller=>"users/registrations", :action=>"create"}
       #   edit_user_registration GET    /users/edit(.:format)     {:controller=>"users/registrations", :action=>"edit"}
       #                          PUT    /users(.:format)          {:controller=>"users/registrations", :action=>"update"}
       #                          DELETE /users(.:format)          {:controller=>"users/registrations", :action=>"destroy"}
-      # 
+      #
       # Generated confirmation routes:
-      # 
+      #
       #       user_confirmation POST   /users/confirmation(.:format)     {:controller=>"users/confirmations", :action=>"create"}
       #   new_user_confirmation GET    /users/confirmation/new(.:format) {:controller=>"users/confirmations", :action=>"new"}
       #                         GET    /users/confirmation(.:format)     {:controller=>"users/confirmations", :action=>"show"}
-      # 
+      #
       # Generated password reset routes:
-      # 
+      #
       #        user_password POST   /users/password(.:format)      {:controller=>"users/passwords", :action=>"create"}
       #    new_user_password GET    /users/password/new(.:format)  {:controller=>"users/passwords", :action=>"new"}
       #   edit_user_password GET    /users/password/edit(.:format) {:controller=>"users/passwords", :action=>"edit"}
       #                      PUT    /users/password(.:format)      {:controller=>"users/passwords", :action=>"update"}
-      # 
+      #
       def janus(*resources)
         ActionController::Base.send(:include, Janus::Helpers)    unless ActionController::Base.include?(Janus::Helpers)
         ActionController::Base.send(:include, Janus::UrlHelpers) unless ActionController::Base.include?(Janus::UrlHelpers)
         options = resources.extract_options!
-        
+
         resources.each do |plural|
           singular = plural.to_s.singularize
-          
+
           if options[:session]
             scope :path => plural, :controller => "#{plural}/sessions" do
-              match "/sign_in(.:format)", :action => "new", :via => :get, :as => "new_#{singular}_session"
-              match "/sign_in(.:format)", :action => "create", :via => :post, :as => "#{singular}_session"
-              match "/sign_out(.:format)", :action => "destroy",  :as => "destroy_#{singular}_session"
+              get    "/sign_in(.:format)",  :action => "new",     :as => "new_#{singular}_session"
+              post   "/sign_in(.:format)",  :action => "create",  :as => "#{singular}_session"
+              delete "/sign_out(.:format)", :action => "destroy", :as => "destroy_#{singular}_session"
             end
           end
-          
+
           namespace plural, :as => singular do
             if options[:registration]
               resource :registration, :except => [:index, :show], :path => "",
                 :path_names => { :new => 'sign_up' }
             end
-            
+
             resource :confirmation, :only => [:show, :new, :create] if options[:confirmation]
             resource :password, :except => [:index, :show, :destroy] if options[:password]
           end
-          
+
           ActionController::Base.janus(singular)
         end
       end