ateam-merb-auth-old 0.0.1

data/lib/merb-auth/adapters/common.rb

@@ -0,0 +1,161 @@
+module MerbAuth
+  module Adapter
+    module Common
+      
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:extend,  ClassMethods)
+      end
+      
+      
+      module InstanceMethods
+        
+        # Encrypts the password with the user salt
+        def encrypt(password)
+          self.class.encrypt(password, salt)
+        end
+        
+        def encrypt_password
+          return if password.blank?
+          self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{MA[:login_field]}--") if new_record?
+          self.crypted_password = encrypt(password)
+        end
+        
+        def authenticated?(password)
+          crypted_password == encrypt(password)
+        end
+        
+        def password_required?
+          crypted_password.blank? || !password.blank?
+        end
+        
+        def activate
+          self.reload unless new_record? # Make sure the model is up to speed before we try to save it
+          set_activated_data!
+          self.save
+
+          # send mail for activation
+          send_activation_notification  if MA[:use_activation]
+        end
+        
+        # Returns true if the user has just been activated.
+        def recently_activated?
+          @activated
+        end
+
+        def activated?
+         return false if self.new_record?
+         !! activation_code.nil?
+        end
+        
+        # Alias for <tt>activated?</tt>
+        def active?; activated?; end
+        
+        def set_login
+          return nil unless self.login.nil?
+          return nil if self.email.nil?
+          logn = self.email.split("@").first
+          # Check that that login is not taken
+          taken_logins = self.class.find_all_with_login_like("#{logn}%").map{|u| u.login}
+          if taken_logins.empty?
+            self.login = logn
+          else
+            taken_logins.first =~ /(\d*)$/
+            if $1.blank?
+              self.login = "#{logn}000"
+            else
+              self.login ="#{logn}#{$1.succ}"
+            end
+          end
+        end
+        
+        def make_activation_code
+          if MA[:use_activation]
+            self.activation_code = self.class.make_key
+          else
+            set_activated_data!
+          end
+        end
+        
+        def remember_token?
+          remember_token_expires_at && DateTime.now < DateTime.parse(remember_token_expires_at.to_s)
+        end
+
+        def remember_me_until(time)
+          self.remember_token_expires_at = time
+          self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
+          save
+        end
+
+        # Useses seconds for the time
+        def remember_me_for(time)
+          time = time / Merb::Const::DAY
+          remember_me_until (DateTime.now + time)
+        end
+
+        # These create and unset the fields required for remembering users between browser closes
+        # Default of 2 weeks 
+        def remember_me
+          remember_me_for (Merb::Const::WEEK * 2)
+        end
+
+        def forget_me
+          self.remember_token_expires_at = nil
+          self.remember_token            = nil
+          self.save
+        end
+        
+        def send_activation_notification
+          if MA[:use_activation]
+            deliver_email(:activation, :subject => (MA[:activation_subject] || "Welcome" ))
+          end
+        end
+
+        def send_signup_notification
+          if MA[:use_activation]
+            deliver_email(:signup, :subject => (MA[:welcome_subject] || "Please Activate Your Account") )
+          end
+        end
+
+        def send_forgot_password
+          deliver_email(:forgot_password, :subject => (MA[:password_request_subject] || "Request to change your password"))
+        end
+
+        def deliver_email(action, params)
+          return if defined?(Merb) && Merb.testing?
+          from = MA[:from_email]
+          MA::UserMailer.dispatch_and_deliver(action, params.merge(:from => from, :to => self.email), MA[:single_resource] => self)
+        end
+        
+        private
+        def set_activated_data!
+          @activated = true
+          self.activated_at = DateTime.now
+          self.activation_code = nil
+          true
+        end       
+        
+      end
+      
+      module ClassMethods
+        
+        # Encrypts some data with the salt.
+        def encrypt(password, salt)
+          Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+        end
+        
+        # Authenticates a user by their login field and unencrypted password.  Returns the user or nil.
+        def authenticate(field, password)
+          @u = find_active_with_conditions(MA[:login_field] => field)
+          @u = @u && @u.authenticated?(password) ? @u : nil
+        end
+        
+        def make_key
+          Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/merb-auth/adapters/datamapper/init.rb

@@ -0,0 +1,28 @@
+require 'dm-validations'
+require 'dm-timestamps'
+require 'dm-aggregates'
+
+path = File.dirname(__FILE__)
+
+if Merb.env?(:test)
+  # Need to make sure the class is removed when testing
+  # It should not impact a normal apps tests
+  if MA[:user]
+    klass =  MA[:user]
+    Object.class_eval do
+      remove_const(klass.name) if klass
+    end  
+  end
+  MA[:user] = nil
+  MerbAuth.module_eval do
+    remove_const("Adapter") if defined?(Adapter)
+  end
+  load path / ".." / "common.rb"
+  load path / "map.rb"
+  load path / "model.rb"
+
+else
+  require path / ".." / "common"
+  require path / "map"
+  require path / "model"
+end

data/lib/merb-auth/adapters/datamapper/map.rb

@@ -0,0 +1,35 @@
+module MerbAuth
+  module Adapter
+    module DataMapper
+      module Map
+      
+        def self.included(base)
+          base.send(:include, InstanceMethods)
+          base.send(:extend,  ClassMethods)
+        end
+      
+        module InstanceMethods
+        end
+      
+        module ClassMethods
+          def find_with_conditions(conditions)
+            first(conditions)
+          end
+        
+          def find_all_with_login_like(logn)
+            all(:login.like => logn, :order => [:login.desc], :limit => 1)
+          end
+                  
+          def find_active_with_conditions(conditions)
+            first(conditions.merge(:activated_at.not => nil))
+          end
+        
+          def clear_database_table
+            auto_migrate!
+          end
+        end # ClassMethods 
+        
+      end # Map
+    end # DataMapper
+  end # Adapters
+end # MerbAuth

data/lib/merb-auth/adapters/datamapper/model.rb

@@ -0,0 +1,72 @@
+module MerbAuth
+  module Adapter
+    module DataMapper
+      
+      def self.included(base)
+        # Ensure base is a resource
+        base.send(:include, ::DataMapper::Resource) unless ::DataMapper::Resource > base
+        
+        # Setup the properties for the model
+        set_model_class_decs!(base)
+        base.send(:include, Map)
+        base.send(:include, InstanceMethods )
+        base.send(:include, Common)
+        
+        MA[:single_resource] ||= base.name.snake_case.gsub("::", "__").to_sym
+        MA[:plural_resource] ||= MA[:single_resource].to_s.pluralize.to_sym
+          
+        MA[:user] = base
+      end
+      
+      module InstanceMethods
+        
+      end # InstanceMethods
+
+      private 
+      def self.set_model_class_decs!(base)
+        base.class_eval do
+          # Sets the login to a downcased version
+          def login=(value)
+            attribute_set(:login, value.downcase) unless value.nil?
+          end
+          
+        end  
+      end # self.set_model_class_decs!
+      
+      module DefaultModelSetup
+        
+        def self.included(base)
+          base.class_eval do
+            attr_accessor :password, :password_confirmation
+
+            property :id,                         Integer,  :serial   => true
+            property :login,                      String,   :nullable => false, :length => 3..40, :unique => true
+            property :email,                      String,   :nullable => false, :unique => true
+            property :created_at,                 DateTime
+            property :updated_at,                 DateTime
+            property :activated_at,               DateTime
+            property :activation_code,            String
+            property :crypted_password,           String
+            property :salt,                       String
+            property :remember_token_expires_at,  DateTime
+            property :remember_token,             String
+            property :password_reset_key,         String, :writer => :protected
+
+            validates_is_unique :password_reset_key, :if => Proc.new{|m| !m.password_reset_key.nil?}
+            validates_present        :password, :if => proc{|m| m.password_required?}
+            validates_is_confirmed   :password, :if => proc{|m| m.password_required?}
+
+            before :valid? do
+              set_login
+            end
+
+            before :save,   :encrypt_password
+            before :create, :make_activation_code
+            after  :create, :send_signup_notification
+          end
+        end
+      end # DefaultModelSetup     
+      
+    end # DataMapper
+  end # Adapter
+end

data/lib/merb-auth/adapters/sequel/init.rb

@@ -0,0 +1,26 @@
+require 'sequel'
+
+path = File.dirname(__FILE__)
+
+if Merb.env?(:test)
+  # Need to make sure the class is removed when testing
+  # It should not impact a normal apps tests
+  if MA[:user]
+    klass =  MA[:user]
+    Object.class_eval do
+      remove_const(klass.name) if klass
+    end  
+  end
+  MA[:user] = nil
+  MerbAuth.module_eval do
+    remove_const("Adapter") if defined?(Adapter)
+  end
+  load path / ".." / "common.rb"
+  load path / "map.rb"
+  load path / "model.rb"
+
+else
+  require path / ".." / "common"
+  require path / "map"
+  require path / "model"
+end

data/lib/merb-auth/adapters/sequel/map.rb

@@ -0,0 +1,36 @@
+module MerbAuth
+  module Adapter
+    module Sequel
+      module Map
+      
+        def self.included(base)
+          base.send(:include, InstanceMethods)
+          base.send(:extend,  ClassMethods)
+        end
+      
+        module InstanceMethods
+        end
+      
+        module ClassMethods
+          def find_with_conditions(conditions)
+            filter(conditions).first
+          end
+        
+          def find_all_with_login_like(logn)
+            filter(:login.like(logn)).order(:login.desc).limit(1)
+          end
+                  
+          def find_active_with_conditions(conditions)
+            #filter(conditions).exclude(:activated_at => nil, :special => true).first
+            filter(conditions).exclude(:activated_at => nil).first
+          end
+        
+          def clear_database_table
+            delete
+          end
+        end # ClassMethods 
+        
+      end # Map
+    end # Sequel
+  end # Adapters
+end # MerbAuth

data/lib/merb-auth/adapters/sequel/model.rb

@@ -0,0 +1,86 @@
+module MerbAuth
+  module Adapter
+    module Sequel
+      
+      def self.included(base)
+        # Ensure base is a resource
+        raise "Mixin class is not an sequel model class" unless base.ancestors.include?(::Sequel::Model)
+        set_model_class_decs!(base)
+        
+        base.send(:include, Map)
+        base.send(:include, InstanceMethods )
+        base.send(:include, Common)
+        
+        MA[:single_resource] ||= base.name.snake_case.to_sym
+        MA[:plural_resource] ||= MA[:single_resource].to_s.pluralize.to_sym
+        
+        MA[:user] = base
+      end
+      
+      
+      module InstanceMethods
+        
+        def login=(login_name)
+          self[:login] = login_name.downcase unless login_name.nil?
+        end
+      
+        def new_record?
+          new?
+        end
+      end
+      
+      
+      private 
+      def self.set_model_class_decs!(base)
+        # base.instance_eval do
+        #   # Virtual attribute for the unencrypted password
+        #   attr_accessor :password, :password_confirmation
+        #   validates_presence_of     :login, :email
+        #   validates_presence_of     :password,                   :if => :password_required?
+        #   validates_presence_of     :password_confirmation,      :if => :password_required?
+        #   validates_length_of       :password, :within => 4..40, :if => :password_required?
+        #   validates_confirmation_of :password,                   :if => :password_required?
+        #   validates_length_of       :login,    :within => 3..40
+        #   validates_length_of       :email,    :within => 3..100
+        #   validates_uniqueness_of   :login, :email, :case_sensitive => false
+        #   validates_uniqueness_of   :password_reset_key, :if => Proc.new{|m| !m.password_reset_key.nil?}
+        #   
+        #   
+        #   before_save :encrypt_password
+        #   before_validation :set_login
+        #   before_create :make_activation_code
+        #   after_create :send_signup_notification
+        # end
+      end
+      
+      module DefaultModelSetup
+        
+        def self.included(base)
+          base.instance_eval do
+            # Virtual attribute for the unencrypted password
+            attr_accessor :password, :password_confirmation
+
+            validates_presence_of     :login, :email
+            validates_presence_of     :password,                   :if => :password_required?
+            validates_presence_of     :password_confirmation,      :if => :password_required?
+            validates_length_of       :password, :within => 4..40, :if => :password_required?
+            validates_confirmation_of :password,                   :if => :password_required?
+            validates_length_of       :login,    :within => 3..40
+            validates_length_of       :email,    :within => 3..100
+            validates_uniqueness_of   :login, :email, :case_sensitive => false
+            validates_uniqueness_of   :password_reset_key, :if => Proc.new{|m| !m.password_reset_key.nil?}
+
+            before_save :encrypt_password
+            before_validation :set_login
+            #before_create :make_activation_code
+            before_save do
+              make_activation_code if id.nil?
+            end
+            after_create :send_signup_notification
+          end
+        end
+      end # DefaultModelSetup
+      
+    end # Sequel
+  end # Adapter
+end # MerbAuth