authentasaurus 0.7.3 → 0.8.3

data/lib/authentasaurus/ar/acts_as_authenticatable.rb

@@ -0,0 +1,113 @@
+module Authentasaurus::Ar
+  module ActsAsAuthenticatable
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      
+      case Rails.application.config.authentasaurus[: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 Rails.application.config.authentasaurus[: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
+    
+    module InstanceMethods
+      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
+end

data/lib/authentasaurus/ar/acts_as_authenticatable_validatable.rb

@@ -0,0 +1,38 @@
+module Authentasaurus::Ar
+  module ActsAsAuthenticatableValidatable
+    def self.included(base)
+      base.send :extend, ActsAsAuthenticatable::ClassMethods
+      base.send :include, ActsAsAuthenticatable::InstanceMethods
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    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
+    
+    module InstanceMethods
+      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
+end

data/lib/authentasaurus/ar/acts_as_overrider.rb

@@ -0,0 +1,51 @@
+module Authentasaurus::Ar
+  Dir[File.dirname(__FILE__) + '/models/*.rb'].each {|file| require file }
+  
+  module ActsAsOverrider
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+    
+    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

@@ -0,0 +1,66 @@
+module Authentasaurus::Ar
+  module Authenticatable
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+    
+    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

@@ -0,0 +1,173 @@
+module Authentasaurus::Ar
+  module Migrations
+    # Extends ActiveRecord::ConnectionAdapters::SchemaStatements
+    module Tables
+      def self.included(base) # :nodoc:
+        base.send :include, InstanceMethods
+      end
+      
+      module InstanceMethods
+        # 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
+    end
+    
+    # Extends ActiveRecord::ConnectionAdapters::TableDefinition
+    module Columns
+      def self.included(base) # :nodoc:
+        base.send :include, InstanceMethods
+      end
+      
+      module InstanceMethods
+        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
+end

data/lib/authentasaurus/{models → ar/models}/recovery.rb

@@ -1,4 +1,4 @@
-module Authentasaurus::Models
+module Authentasaurus::Ar::Models
   module Recovery
     def self.included(base) # :nodoc:
       base.send :extend, ClassMethods
@@ -10,10 +10,10 @@ module Authentasaurus::Models
       
       base.send :belongs_to, :user
       
-    	base.send :before_validation_on_create, :make_token!
+    	base.send :before_validation, :make_token!, :on => :create
     	base.send :before_save, :send_recovery
       
-    	base.send :named_scope, :valid, lambda { { :conditions => ["updated_at <= ?", Rails.application.config.authentasaurus[:modules][:recoverable][:token_expires_after].days.from_now] } }
+    	base.send :scope, :valid, lambda { { :conditions => ["updated_at <= ?", Rails.application.config.authentasaurus[:modules][:recoverable][:token_expires_after].days.from_now] } }
       
     	base.send :validates_uniqueness_of, :user_id
     	base.send :validates_presence_of, :email