authentasaurus 0.4.14 → 0.5.6

data/lib/authentasaurus/models/group.rb

@@ -1,8 +1,17 @@
-class Authentasaurus::Models::Group < ActiveRecord::Base
-  has_many :permissions, :dependent => :destroy
-  has_many :areas, :through => :permissions
-
-  # Check that everything is there
-  validates_presence_of :name
+module Authentasaurus::Models::Group
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+    
+    base.send :has_many, :permissions, :dependent => :destroy
+    base.send :has_many, :areas, :through => :permissions
+    
+    base.send :validates_presence_of, :name
+  end
   
+  module ClassMethods
+  end
+  
+  module InstanceMethods
+  end
 end

data/lib/authentasaurus/models/permission.rb

@@ -1,9 +1,20 @@
-class Authentasaurus::Models::Permission < ActiveRecord::Base
-  belongs_to :group
-  belongs_to :area
-
-  # Check that everything is there
-  validates_presence_of :group_id,:area_id,:read,:write
-  # Check foreign keys
-  validates_associated :group, :area
+module Authentasaurus::Models::Permission
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+    
+    base.send :belongs_to, :group
+    base.send :belongs_to, :area
+  
+    # Check that everything is there
+    base.send :validates_presence_of, :group_id,:area_id,:read,:write
+    # Check foreign keys
+    base.send :validates_associated, :group, :area
+  end
+  
+  module ClassMethods
+  end
+  
+  module InstanceMethods
+  end
 end

data/lib/authentasaurus/models/recovery.rb

@@ -1,23 +1,33 @@
-class Authentasaurus::Models::Recovery < ActiveRecord::Base
-  require "digest/sha1"
-	belongs_to :user
+module Authentasaurus::Models::Recovery
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+    
+    base.send :require, "digest/sha1"
+    
+    base.send :belongs_to, :user
 	
-	before_validation_on_create :make_token!
-	before_save :send_recovery
-	
-	named_scope :valid, lambda { { :conditions => ["updated_at <= ?", AUTHENTASAURUS[:modules][:recoverable][:token_expires_after].days.from_now] } }
-	
-	validates_uniqueness_of :user_id
-	validates_presence_of :email
-	validates_presence_of :user_id, :message => :"recovery.user_id.blank"
-	validates_format_of :email, :with => %r{[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}}
-	
-	
-	def make_token!
-		self.token = Digest::SHA1.hexdigest "#{Time.now.to_i} #{rand} #{self.email}"
-	end
-	
-	def send_recovery
-		AuthentasaurusEmailer.deliver_recovery_mail(self.user, self.token) if AUTHENTASAURUS[:modules][:recoverable][:send_email]
-	end
+  	base.send :before_validation_on_create, :make_token!
+  	base.send :before_save, :send_recovery
+  	
+  	base.send :named_scope, :valid, lambda { { :conditions => ["updated_at <= ?", AUTHENTASAURUS[:modules][:recoverable][:token_expires_after].days.from_now] } }
+  	
+  	base.send :validates_uniqueness_of, :user_id
+  	base.send :validates_presence_of, :email
+  	base.send :validates_presence_of, :user_id, :message => :"recovery.user_id.blank"
+  	base.send :validates_format_of, :email, :with => %r{[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}}
+  end
+  
+  module ClassMethods
+  end
+  
+  module InstanceMethods
+  	def make_token!
+  		self.token = Digest::SHA1.hexdigest "#{Time.now.to_i} #{rand} #{self.email}"
+  	end
+  	
+  	def send_recovery
+  		AuthentasaurusEmailer.deliver_recovery_mail(self.user, self.token) if AUTHENTASAURUS[:modules][:recoverable][:send_email]
+  	end
+  end
 end

data/lib/authentasaurus/models/session.rb

@@ -1,63 +1,72 @@
 # This class represents a session model, a session authenticates a username and a password.
 #
 # A session behaves just like an ActiveRecord model
-class Authentasaurus::Models::Session
-  attr_accessor :username, :password, :remember
-  attr_accessor :errors
-  attr_reader :user
+module Authentasaurus::Models::Session
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+    
+    base.send :attr_accessor, :username, :password, :remember
+    base.send :attr_accessor, :errors
+    base.send :attr_reader, :user
+  end
   
-  # Takes a hash of attributes keys and values just like ActiveRecord models
-  def initialize(attributes = nil)
-    self.errors = ActiveRecord::Errors.new(self)
-    if attributes
-      attributes.each do |key,value|
-        send(key.to_s + '=', value)
-      end
-    else
-      self.remember = false
+  module ClassMethods
+    # Takes a hash of attributes keys and values just like new and authenticates the information.
+    # Returns true or false
+    def create(*attrs)
+      attributes = attrs.extract_options!
+      attrs = attrs.flatten
+      self_obj = self.new attributes
+      self_obj.save(attrs)
+      return self_obj
+    end
+    
+    # Takes an id (usually from an ActiveController session) and returns a User object
+    def current_user(id, session_type = :user)
+      session_type.to_s.camelize.constantize.find id
     end
   end
   
-  # Authenticates the information saved in the attributes
-  # Returns true or false
-  def save(*session_types)
-    session_types = session_types.flatten
-    
-    if session_types.empty?
-      session_types = [:user]
+  module InstanceMethods
+    # Takes a hash of attributes keys and values just like ActiveRecord models
+    def initialize(attributes = nil)
+      self.errors = ActiveRecord::Errors.new(self)
+      if attributes
+        attributes.each do |key,value|
+          send(key.to_s + '=', value)
+        end
+      else
+        self.remember = false
+      end
     end
     
-    ret = true
-    session_types.each do |type|
-      @user = type.to_s.camelize.constantize.authenticate(self.username, self.password)
-      if @user.nil?
-        self.errors.add_to_base I18n.t(:invalid_login, :scope => [:authentasaurus, :messages, :sessions]) 
-        ret &= false
-      else
-        @user.create_remember_me_token if self.remember == "1"
-        ret = true
-        break
+    # Authenticates the information saved in the attributes
+    # Returns true or false
+    def save(*session_types)
+      session_types = session_types.flatten
+      
+      if session_types.empty?
+        session_types = [:user]
       end
+      
+      ret = true
+      session_types.each do |type|
+        @user = type.to_s.camelize.constantize.authenticate(self.username, self.password)
+        if @user.nil?
+          self.errors.add_to_base I18n.t(:invalid_login, :scope => [:authentasaurus, :messages, :sessions]) 
+          ret &= false
+        else
+          @user.create_remember_me_token if self.remember == "1"
+          ret = true
+          break
+        end
+      end
+      ret
+    end
+    
+    def new_record? #:nodoc:
+      true
     end
-    ret
-  end
-  
-  # Takes a hash of attributes keys and values just like new and authenticates the information.
-  # Returns true or false
-  def self.create(*attrs)
-    attributes = attrs.extract_options!
-    attrs = attrs.flatten
-    self_obj = self.new attributes
-    self_obj.save(attrs)
-    return self_obj
-  end
-  
-  def new_record? #:nodoc:
-    true
-  end
-  
-  # Takes an id (usually from an ActiveController session) and returns a User object
-  def self.current_user(id, session_type = :user)
-    session_type.to_s.camelize.constantize.find id
   end
 end

data/lib/authentasaurus/models/user_invitation.rb

@@ -1,21 +1,31 @@
-class Authentasaurus::Models::UserInvitation < ActiveRecord::Base
-  require 'digest/sha1'
-  validates_presence_of :email
-  validates_uniqueness_of :email, :scope => :token
-  validates_format_of :email, :with => %r{[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}}
+module Authentasaurus::Models::UserInvitation
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+    
+    base.send :require, 'digest/sha1'
+    base.send :validates_presence_of, :email
+    base.send :validates_uniqueness_of, :email, :scope => :token
+    base.send :validates_format_of, :email, :with => %r{[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}}
+    
+    base.send :before_validation, :create_token
+    #send email
+    base.send :after_create, :send_invitation
+  end
   
-  before_validation :create_token
-  #send email
-  after_create :send_invitation
-
-  def send_invitation
-    AuthentasaurusEmailer.deliver_invitation_mail(self.email, self.token) if AUTHENTASAURUS[:modules][:invitable][:send_email]
+  module ClassMethods
   end
   
-  private
-  def create_token
-    return if self.email.nil? || self.email.blank?
-    string_to_hash=self.email + "invitable.olation" + self.email.hash.to_s
-		self.token = Digest::SHA1.hexdigest(string_to_hash)
+  module InstanceMethods
+    def send_invitation
+      AuthentasaurusEmailer.deliver_invitation_mail(self.email, self.token) if AUTHENTASAURUS[:modules][:invitable][:send_email]
+    end
+    
+    private
+    def create_token
+      return if self.email.nil? || self.email.blank?
+      string_to_hash=self.email + "invitable.olation" + self.email.hash.to_s
+  		self.token = Digest::SHA1.hexdigest(string_to_hash)
+    end
   end
 end

data/lib/authentasaurus/models/validation.rb

@@ -1,18 +1,28 @@
-class Authentasaurus::Models::Validation < ActiveRecord::Base
-  belongs_to :user, :polymorphic => true
+module Authentasaurus::Models::Validation
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+    
+    base.send :belongs_to, :user, :polymorphic => true
   
-  # Check that everything is there
-  validates_presence_of :user_id, :validation_code, :user_type, :email
-  # Check foreign keys
-  validates_associated :user
-  # Check unique user
-  validates_uniqueness_of :user_id, :scope => [:user_type, :email]
-  validates_uniqueness_of :validation_code
-
-  #send email
-  after_create :send_validation
-
-  def send_validation
-    AuthentasaurusEmailer.deliver_validation_mail(self.user.name, self.email, self.validation_code) if AUTHENTASAURUS[:modules][:validatable][:send_email]
+    # Check that everything is there
+    base.send :validates_presence_of, :user_id, :validation_code, :user_type, :email
+    # Check foreign keys
+    base.send :validates_associated, :user
+    # Check unique user
+    base.send :validates_uniqueness_of, :user_id, :scope => [:user_type, :email]
+    base.send :validates_uniqueness_of, :validation_code
+  
+    #send email
+    base.send :after_create, :send_validation
+  end
+  
+  module ClassMethods
+  end
+  
+  module InstanceMethods
+    def send_validation
+      AuthentasaurusEmailer.deliver_validation_mail(self.user.name, self.email, self.validation_code) if AUTHENTASAURUS[:modules][:validatable][:send_email]
+    end
   end
 end

data/lib/authentasaurus/permissions_controller.rb

@@ -1,70 +1,79 @@
-class Authentasaurus::PermissionsController < Authentasaurus::AuthentasaurusController
-	
-	def index
-		@permissions = Permission.find :all
-		
-		respond_to do |format|
-			format.html
-		end
-	end
-	
-	def show
-		@permission = Permission.find params[:id]
-		
-		respond_to do |format|
-			format.html
-		end
-	end
-	
-	def new
-		@permission = Permission.new
-		
-		respond_to do |format|
-			format.html
-		end
-	end
-	
-	def create
-		@permission = Permission.new params[:permission]
-		
-		respond_to do |format|
-			if @permission.save
-				format.html { redirect_to :action=>:index, :notice => "Permission created" }
-			else
-				flash.now[:alert] = I18n.t(:create_failed, :scope => [:authentasaurus, :messages, :permissions])
-				format.html { render :new }
-			end
-		end
-	end
-	
-	def edit
-		@permission = Permission.find params[:id]
-		
-		respond_to do |format|
-			format.html
-		end
-	end
-	
-	def update
-		@permission = Permission.find params[:id]
-		
-		respond_to do |format|
-			if @permission.update_attributes(params[:permission])
-				flash.now[:notice] = "Permission updated"
-				format.html { redirect_to @permission }
-			else
-				flash.now[:alert] = I18n.t(:update_failed, :scope => [:authentasaurus, :messages, :permissions])
-				format.html { render :edit }
-			end
-		end
-	end
-	
-	def destroy
-		@permssion = Permission.find params[:id]
-		@permission.destroy()
-		
-		respond_to do |format|
-			format.html { redirect_to :action=>:index }
-		end
-	end
+module Authentasaurus::PermissionsController
+  def self.included(base) # :nodoc:
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+  end
+  
+  module ClassMethods
+  end
+  
+  module InstanceMethods
+    def index
+  		@permissions = Permission.find :all
+  		
+  		respond_to do |format|
+  			format.html
+  		end
+  	end
+  	
+  	def show
+  		@permission = Permission.find params[:id]
+  		
+  		respond_to do |format|
+  			format.html
+  		end
+  	end
+  	
+  	def new
+  		@permission = Permission.new
+  		
+  		respond_to do |format|
+  			format.html
+  		end
+  	end
+  	
+  	def create
+  		@permission = Permission.new params[:permission]
+  		
+  		respond_to do |format|
+  			if @permission.save
+  				format.html { redirect_to :action=>:index, :notice => "Permission created" }
+  			else
+  				flash.now[:alert] = I18n.t(:create_failed, :scope => [:authentasaurus, :messages, :permissions])
+  				format.html { render :new }
+  			end
+  		end
+  	end
+  	
+  	def edit
+  		@permission = Permission.find params[:id]
+  		
+  		respond_to do |format|
+  			format.html
+  		end
+  	end
+  	
+  	def update
+  		@permission = Permission.find params[:id]
+  		
+  		respond_to do |format|
+  			if @permission.update_attributes(params[:permission])
+  				flash.now[:notice] = "Permission updated"
+  				format.html { redirect_to @permission }
+  			else
+  				flash.now[:alert] = I18n.t(:update_failed, :scope => [:authentasaurus, :messages, :permissions])
+  				format.html { render :edit }
+  			end
+  		end
+  	end
+  	
+  	def destroy
+  		@permssion = Permission.find params[:id]
+  		@permission.destroy()
+  		
+  		respond_to do |format|
+  			format.html { redirect_to :action=>:index }
+  		end
+  	end
+  end
 end