authentasaurus 0.8.8 → 0.8.9

data/lib/authentasaurus/ac/controllers/validations_controller.rb

@@ -1,48 +0,0 @@
-module Authentasaurus::Ac::Controllers
-  module ValidationsController
-    extend ActiveSupport::Concern
-    
-    module ClassMethods
-    end
-        
-    def validate
-      respond_to do |format|
-        format.html
-      end
-    end
-    
-    def activate
-  		respond_to do |format|
-        validation = Validation.find_by_validation_code(params[:vcode])
-  			if validation
-          validation.user.activate
-          validation.destroy
-          format.html { redirect_to login_url, :notice => I18n.t(:validation_successful, :scope => [:authentasaurus, :messages, :validations])}
-        else
-          flash.now[:alert] = I18n.t(:validation_failed, :scope => [:authentasaurus, :messages, :validations])
-          format.html { render :validate }
-        end
-      end
-    end
-    
-  	def resend_validation_email
-  	  respond_to do |format|
-        format.html
-      end
-    end
-    
-    def do_resend_validation_email
-      validation = Validation.find_by_email params[:email]
-      
-      respond_to do |format|
-        unless validation.nil?
-          validation.send_validation
-          format.html {redirect_to login_url, :notice => I18n.t(:validation_email_sent, :scope => [:authentasaurus, :messages, :validations])}
-        else
-          flash.now[:alert] = I18n.t(:validation_email_invalid, :scope => [:authentasaurus, :messages, :validations], :email => params[:email])
-          format.html { render :resend_validation_email }
-        end
-      end
-    end
-  end  
-end

data/lib/authentasaurus/ac/routing.rb

@@ -1,86 +0,0 @@
-## Authentasaurus routes helper
-module Authentasaurus::Ac
-  module Routing
-    extend ActiveSupport::Concern
-        
-    # TODO: add documentation here
-    def authentasaurus_routes(*opts)
-      options = opts.extract_options!
-      
-      # Authenticatable
-      authentasaurus_sessions options.dup
-      authentasaurus_users options.dup
-      # Recoverable
-      authentasaurus_recoverable
-      
-      # Authorizable
-      if opts.include?(:authorization)
-        authentasaurus_authorizable options.dup
-      end
-      
-      # Validatable
-      if opts.include?(:validation)
-        authentasaurus_validatable
-      end
-      
-      # Invitable
-      if opts.include?(:invitation)
-        authentasaurus_invitable options.dup
-        authentasaurus_invitable_public
-      end
-    end
-    
-    # TODO: add documentation here
-    def authentasaurus_sessions(*opts)
-      get     "/sessions/sign-in(.:format)" => "sessions#new", :as => :new_authentasaurus_session
-      post    "/sessions(.:format)" => "sessions#create", :as => :authentasaurus_sessions
-      delete  "/sessions/sign-out(.:format)" => "sessions#destroy", :as => :authentasaurus_session
-      get     "/sessions/no-access(.:format)" => "sessions#no_access", :as => :no_access_authentasaurus_sessions
-    end
-    
-    # TODO: add documentation here
-    def authentasaurus_users(*opts)
-      options = opts.extract_options!
-      
-      resources :users, options.dup
-    end
-    
-    # TODO: add documentation here
-    def authentasaurus_authorizable(*opts)
-      options = opts.extract_options!
-      
-      resources :groups, options.dup
-      resources :areas, options.dup
-      resources :permissions, options.dup
-    end
-    
-    # TODO: add documentation here
-    def authentasaurus_validatable
-      match "/validate" => "validations#validate", :as => 'validate'
-      match "/activate" => "validations#activate", :as => 'activate'
-      match "/resend-validation" => "validations#resend_validation_email", :via => :get, :as => 'recover_password'
-      match "/resend-validation" => "validations#do_resend_validation_email", :via => :post, :as => 'do_recover_password'
-    end
-    
-    # TODO: add documentation here
-    def authentasaurus_invitable(*opts)
-      options = opts.extract_options!
-      
-      resources :user_invitations, options.dup.merge({:except => [:show, :edit, :update]})
-    end
-    
-    def authentasaurus_invitable_public(*opts)
-      options = opts.extract_options!
-      
-      resources :registrations, :only => [:new, :create], :path_prefix => "/:token", :requirements => {:token => /[0-9a-zA-Z]+/}
-    end
-    
-    # TODO: add documentation here
-    def authentasaurus_recoverable      
-      match "/forgot-password" => "recoveries#new", :via => :get, :as => 'forgot_password'
-      match "/forgot-password" => "recoveries#create", :via => :post, :as => 'do_forgot_password'
-      match "/recover-password/:token" => "recoveries#edit", :via => :get, :as => 'recover_password'
-      match "/recover-password/:token" => "recoveries#destroy", :via => :delete, :as => 'do_recover_password'
-    end
-  end    
-end

data/lib/authentasaurus/ar/acts_as_authenticatable.rb

@@ -1,107 +0,0 @@
-module Authentasaurus::Ar
-  module ActsAsAuthenticatable
-    extend ActiveSupport::Concern
-    
-    module ClassMethods
-      case Authentasaurus::Configuration.instance.hashing
-      when "SHA2"
-        require 'digest/sha2'
-      when "SHA1"
-        require 'digest/sha1'
-      when "MD5"
-        require 'digest/md5'
-      else
-        require 'digest/sha2'
-      end
-      
-      
-      ## Authenticates the username (or email) and password
-      def authenticate(username_or_email, password, remember = false)
-        user=self.find_by_username(username_or_email) || self.find_by_email(username_or_email)
-        if user
-          expected_password=encrypt_password(password, user.password_seed)
-          unless expected_password == user.hashed_password && user.active
-            user = nil 
-          else
-            user.create_remember_me_token if remember
-          end
-        end
-        return user
-      end
-      
-      ## Encrypts the password using the given seed
-      def encrypt_password(password, password_seed)
-  			pass_to_hash=password + "Securasaurus" + password_seed
-        
-        case Authentasaurus::Configuration.instance.hashing
-        when "SHA2"
-          Digest::SHA2.hexdigest(pass_to_hash)
-        when "SHA1"
-          Digest::SHA1.hexdigest(pass_to_hash)
-        when "MD5"
-          Digest::MD5.hexdigest(pass_to_hash)
-        else
-          Digest::SHA2.hexdigest(pass_to_hash)
-        end
-        
-      end
-    end
-    
-    def username=(username)      
-      super(username.downcase)
-    end
-      
-    ## Password attribute (used when creating a user)
-    def password
-      return @password
-    end
-    
-    def password=(pwd)
-      @password = pwd
-      return if pwd.blank?
-      create_salt
-      self.hashed_password = self.class.encrypt_password(@password, self.password_seed)
-    end
-    
-    ## New password attribute (used when editing a user)
-    def new_password
-      return @new_password
-    end
-    
-    def new_password=(pwd)
-      @new_password = pwd
-      return if pwd.blank?
-      create_salt
-      self.hashed_password = self.class.encrypt_password(@new_password, self.password_seed)
-    end
-    
-    def activate
-      self.update_attribute :active, true
-    end
-    
-    def deactivate
-      self.update_attribute :active, false
-    end
-    
-    def create_remember_me_token
-      pass_to_hash=Time.now.to_i.to_s + "Securasaurus" + password_seed
-      self.update_attribute :remember_me_token, Digest::SHA1.hexdigest(pass_to_hash)
-      self.remember_me_token
-    end
-    
-    private
-    def new_password_blank? 
-			self.new_password.blank?
-    end
-    
-		## Creates password seed (salt)
-    def create_salt
-			self.password_seed = self.object_id.to_s + rand.to_s
-    end
-    
-		## Dont delete the last user
-    def dont_delete_admin
-		  raise "You cannot delete the last admin" if self.id == 1 || User.count == 1
-    end
-  end  
-end

data/lib/authentasaurus/ar/acts_as_authenticatable_validatable.rb

@@ -1,35 +0,0 @@
-module Authentasaurus::Ar
-  module ActsAsAuthenticatableValidatable
-    extend ActiveSupport::Concern
-    
-    included do      
-      include ActsAsAuthenticatable
-    end
-    
-    module ClassMethods
-      ## Authenticates the username (or email) and password
-      def authenticate(username_or_email, password, remember = false)
-        user=self.find_by_username(username_or_email) || self.find_by_email(username_or_email)
-        if user
-          expected_password=encrypt_password(password, user.password_seed)
-          unless expected_password == user.hashed_password && user.active && user.validation.nil?    
-            user = nil 
-          else
-            user.create_remember_me_token if remember
-          end
-        end
-        return user
-      end
-    end
-    
-    private
-    def send_validation
-      unless self.active
-				validation = self.build_validation(:email => self.email, :validation_code => User.encrypt_password(self.username,self.password_seed))
-        unless validation.save
-					raise "Could not create validation record"
-        end
-      end
-    end
-  end    
-end

data/lib/authentasaurus/ar/acts_as_overrider.rb

@@ -1,49 +0,0 @@
-module Authentasaurus::Ar
-  Dir[File.dirname(__FILE__) + '/models/*.rb'].each {|file| require file }
-  
-  module ActsAsOverrider
-    extend ActiveSupport::Concern    
-    
-    module ClassMethods
-      def acts_as_area        
-        unloadable
-      
-        has_many :permissions, :dependent => :destroy
-        has_many :groups, :through => :permissions
-      
-        validates_presence_of :name
-      end
-      
-      def acts_as_group
-        has_many :permissions, :dependent => :destroy
-        has_many :areas, :through => :permissions
-        
-        validates_presence_of :name
-      end
-      
-      def acts_as_permission
-        unloadable
-      
-        belongs_to :group
-        belongs_to :area
-        
-        # Check that everything is there
-        validates_presence_of :group_id, :area_id
-        # Check foreign keys
-        validates_associated :group, :area
-      end
-      
-      def acts_as_recovery
-        include Authentasaurus::Ar::Models::Recovery
-      end
-      
-      def acts_as_user_invitation
-        include Authentasaurus::Ar::Models::UserInvitation
-      end
-      
-      def acts_as_validation
-        include Authentasaurus::Ar::Models::Validation
-      end
-    end
-  end
-end

data/lib/authentasaurus/ar/authenticatable.rb

@@ -1,64 +0,0 @@
-module Authentasaurus::Ar
-  module Authenticatable
-    extend ActiveSupport::Concern
-    
-    module ClassMethods
-      def authenticatable(*args)
-        options = args.extract_options!
-        args = args.flatten
-        # Associations
-        belongs_to :group
-        has_many :permissions, :through => :group
-        # Validation
-        # basic attributes
-        validates_presence_of :username, :hashed_password, :password_seed, :email, :name
-        validates_uniqueness_of :username, :email
-        validates_format_of :username, :with => /^[a-z0-9]*([a-z0-9]{4})+[a-z0-9]*$/ # alpha-numeric only and at least 4 characters
-        validates_format_of :email, :with => %r{[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}}
-        # password validations
-        validates_confirmation_of :password, :on => :create, :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        validates_presence_of :password, :on => :create, :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        validates_length_of :password, :minimum => 6, :on => :create, :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-        # new password
-        validates_confirmation_of :new_password, :on => :update, :unless => :new_password_blank?
-        validates_length_of :new_password, :minimum => 6, :on => :update, :unless => :new_password_blank?
-        # format of password
-        if args.include?(:strong_password)
-          validates_format_of :password, :with => %r{[a-z]}, :on => :create, :message => :"authenticatable.lower_case_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-          validates_format_of :password, :with => %r{[A-Z]}, :on => :create, :message => :"authenticatable.upper_case_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-          validates_format_of :password, :with => %r{[0-9]}, :on => :create, :message => :"authenticatable.digit_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-          validates_format_of :password, :with => %r{[@$%!&]}, :on => :create, :message => :"authenticatable.symbol_password", :if => Proc.new {|user| user.hashed_password.nil? || user.password_seed.nil? }
-          # new password
-          validates_format_of :new_password, :with => %r{[a-z]}, :on => :update, :message => :"authenticatable.lower_case_password", :unless => :new_password_blank?
-          validates_format_of :new_password, :with => %r{[A-Z]}, :on => :update, :message => :"authenticatable.upper_case_password", :unless => :new_password_blank?
-          validates_format_of :new_password, :with => %r{[0-9]}, :on => :update, :message => :"authenticatable.digit_password", :unless => :new_password_blank?
-          validates_format_of :new_password, :with => %r{[@$%!&]}, :on => :update, :message => :"authenticatable.symbol_password", :unless => :new_password_blank?
-        end
-        
-        # Accessors
-        attr_accessor :password_confirmation, :new_password_confirmation
-        
-        # default data
-        class << self
-          attr_accessor :default_data
-        end
-        
-        @default_data = {}
-        
-        # dont delete admin
-        before_destroy :dont_delete_admin
-        
-        #validation
-        if args.include?(:validatable)
-          has_one :validation, :as => :user
-          after_create :send_validation
-          # include authentication methods including validation
-          include ActsAsAuthenticatableValidatable
-        else
-          # include authentication methods
-          include ActsAsAuthenticatable
-        end
-      end
-    end
-  end
-end

data/lib/authentasaurus/ar/migrations.rb

@@ -1,165 +0,0 @@
-module Authentasaurus::Ar
-  module Migrations
-    # Extends ActiveRecord::ConnectionAdapters::SchemaStatements
-    module Tables
-      extend ActiveSupport::Concern
-            
-      # creates all tables
-      def authentasaurus_tables
-        authentasaurus_user :authorizable
-        authentasaurus_group
-        authentasaurus_area
-        authentasaurus_permission
-        authentasaurus_validation
-        authentasaurus_user_invitation
-        authentasaurus_recovery
-      end
-        
-        # creates users table
-      def authentasaurus_user(*opts)
-        create_table :users do |t|
-          t.string :username, :null => false
-          t.string :hashed_password, :null => false
-          t.string :password_seed, :null => false
-          t.string :name, :null => false
-          t.string :email, :null => false
-          t.boolean :active, :null => false, :default => false
-          t.string :remember_me_token
-          
-          if opts.include?(:authorizable) || opts.include?("authorizable")
-            t.integer :group_id, :null => false
-          end
-          
-          t.timestamps
-        end
-      end
-      
-      # creates groups table
-      def authentasaurus_group
-        create_table :groups do |t|
-          t.string :name, :null => false
-          
-          t.timestamps
-        end
-      end
-      
-      # creates areas table
-      def authentasaurus_area
-        create_table :areas do |t|
-          t.string :name, :null => false
-          
-          t.timestamps
-        end
-      end
-      
-      # creates permissions table
-      def authentasaurus_permission
-        create_table :permissions do |t|
-          t.integer :group_id, :null => false
-          t.integer :area_id, :null => false
-          t.boolean :read, :null => false, :default => false
-          t.boolean :write, :null => false, :default => false
-          
-          t.timestamps
-        end
-      end
-      
-      # creates validations table
-      def authentasaurus_validation
-        create_table :validations do |t|
-          t.integer :user_id, :null => false
-          t.string  :user_type, :null => false
-          t.string :email, :null => false
-          t.string :validation_code, :null => false
-          
-          t.timestamps
-        end
-      end
-      
-      # creates user_invitations table
-      def authentasaurus_user_invitation
-        create_table :user_invitations do |t|
-          t.string  :token, :null => false, :unique => true
-          t.string  :email
-          
-          t.timestamps
-        end
-      end
-      
-      # creates recoveries table
-		  def authentasaurus_recovery
-		    create_table :recoveries do |t|
-          t.integer :user_id, :null => false
-          t.string  :email, :null => false
-          t.string :token, :null => false, :unique => true
-          
-          t.timestamps
-        end
-      end
-      
-      # drops all tables
-      def authentasaurus_drop_tables
-        authentasaurus_drop_user
-        authentasaurus_drop_group
-        authentasaurus_drop_area
-        authentasaurus_drop_permission
-        authentasaurus_drop_validation
-        authentasaurus_drop_user_invitation
-        authentasaurus_drop_recovery
-      end
-      
-      # drops users table
-      def authentasaurus_drop_user
-        drop_table :users
-      end
-      
-      # drops groups table
-      def authentasaurus_drop_group
-        drop_table :groups
-      end
-      
-      # drops areas table
-      def authentasaurus_drop_area
-        drop_table :areas
-      end
-      
-      # drops permissions table
-      def authentasaurus_drop_permission
-        drop_table :permissions
-      end
-      
-      # drops validations table
-      def authentasaurus_drop_validation
-        drop_table :validations
-      end
-      
-      # drops user_invitations table
-      def authentasaurus_drop_user_invitation
-        drop_table :user_invitations
-      end
-      
-      # drops recoveries table
-      def authentasaurus_drop_recovery
-        drop_table :recoveries
-      end
-    end    
-    
-    # Extends ActiveRecord::ConnectionAdapters::TableDefinition
-    module Columns
-      extend ActiveSupport::Concern
-            
-      def user(*opts)
-        string :username, :null => false
-        string :hashed_password, :null => false
-        string :password_seed, :null => false
-        string :name, :null => false
-        string :email, :null => false
-        string :remember_me_token
-        boolean :active, :null => false, :default => false
-        if opts.include?(:authorizable)
-          integer :group_id, :null => false
-        end
-      end
-    end
-  end    
-end