simple_auth 0.1.0

data/README.markdown

@@ -0,0 +1,136 @@
+Simple Auth
+===========
+
+SimpleAuth is an authentication library to be used when Authlogic & Devise are just too complicated.
+
+This library only supports in-site authentication and won't implement OpenID, Facebook Connect and like.
+
+Installation
+------------
+
+As plugin:
+
+	script/plugin install git://github.com/fnando/simple_auth.git
+
+As gem:
+
+	sudo gem install simple_auth
+
+Then run `script/generate simple_auth` to copy the initializer file.
+
+Usage
+-----
+
+Your user model should have the attributes `password_hash` and `password_salt`. The credential field can be anything you want, but SimpleAuth uses `[:email, :login]` by default.
+
+	class CreateUsers < ActiveRecord::Migration
+	  def self.up
+	    create_table :users do |t|
+	      t.string :email
+	      t.string :login
+	      t.string :password_hash
+	      t.string :password_salt
+
+	      t.timestamps
+	    end
+
+		add_index :users, :email
+		add_index :users, :login
+		add_index :users, [:email, :login]
+	  end
+
+	  def self.down
+	    drop_table :users
+	  end
+	end
+
+If your user model is other than `User`, you have to set it in your `config/initializer/simple_auth.rb` initializer file.
+You can also set up the credentials attributes.
+
+	SimpleAuth.setup do |config|
+	  config.model = :account
+	  config.credentials = [:username]
+	end
+
+On your model, call the method `has_authentication`.
+
+	class User < ActiveRecord::Base
+	  has_authentication
+	end
+
+This will add some callbacks and password validations.
+
+After you set up the model, you can go the controller.
+
+	class SessionsController < ApplicationController
+	  def new
+	    @user_session = SimpleAuth::Session.new
+	  end
+
+	  def create
+	    @user_session = SimpleAuth::Session.new(params[:session])
+
+	    if @user_session.save
+	      redirect_to dashboard_path
+	    else
+	      flash[:warning] = "Invalid username or password"
+	      render :new
+	    end
+	  end
+
+	  def destroy
+	    current_session.destroy if logged_in?
+	    redirect_to root_path
+	  end
+	end
+
+There are some helpers:
+
+	logged_in?				# controller & views
+	current_user			# controller & views
+	current_session         # controller & views
+	when_logged(&block)		# views
+
+Troubleshooting
+---------------
+
+You may receive strange errors related to `can't dup NilClass` or `You have a nil object when you didn't expect it!`. This will occur only on development mode and is an ActiveRecord bug that hasn't been fixed. Open the ActiveRecord file  `activerecord-2.3.5/lib/active_record/base.rb` and comment the lines 411-412:
+
+	klass.instance_variables.each { |var| klass.send(:remove_instance_variable, var) }
+	klass.instance_methods(false).each { |m| klass.send :undef_method, m }
+
+Dirty, but it works. Here's the ticket for this issue: [LINK TO LIGHTHOUSE TICKET]
+
+To-Do
+-----
+
+* Write README
+
+Maintainer
+----------
+
+* Nando Vieira (<http://simplesideias.com.br>)
+
+License:
+--------
+
+(The MIT License)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+require 'jeweler'
+require File.dirname(__FILE__) + '/lib/simple_auth/version'
+
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format specdoc --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+JEWEL = Jeweler::Tasks.new do |gem|
+  gem.name = "simple_auth"
+  gem.version = SimpleAuth::Version::STRING
+  gem.summary = "A simple authentication system for Rails apps"
+  gem.description = <<-TXT
+When Authlogic & Devise are just too much.
+TXT
+
+  gem.authors = ["Nando Vieira"]
+  gem.email = "fnando.vieira@gmail.com"
+  gem.homepage = "http://github.com/fnando/simple_auth"
+
+  gem.has_rdoc = false
+  gem.files = %w(Rakefile simple_auth.gemspec init.rb VERSION README.markdown) + Dir["{generators,lib,spec,app,config}/**/*"]
+end
+
+desc "Generate gemspec and build gem"
+task :build_gem do
+  File.open("VERSION", "w+") {|f| f << SimpleAuth::Version::STRING }
+
+  Rake::Task["gemspec"].invoke
+  Rake::Task["build"].invoke
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/app/helpers/simple_auth_helper.rb

@@ -0,0 +1,10 @@
+module SimpleAuthHelper
+  # Renders the specified block for logged users.
+  #
+  #   <% when_logged do %>
+  #     <!-- content for logged users -->
+  #   <% end %>
+  def when_logged(&block)
+    capture(&block) if logged_in?
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  simple_auth:
+    sessions:
+      need_to_be_logged: "You need to be logged"
+      invalid_credentials: "Invalid username or password"

data/config/locales/pt.yml

@@ -0,0 +1,11 @@
+pt: &pt
+  simple_auth:
+    sessions:
+      need_to_be_logged: "Você precisa estar logado"
+      invalid_credentials: "Usuário ou senha inválidos"
+
+pt-BR:
+  <<: *pt
+
+pt-PT:
+  <<: *pt

data/generators/simple_auth/USAGE

@@ -0,0 +1,5 @@
+Description:
+  Create an initializer file for SimpleAuth library.
+
+Examples:
+    script/generate simple_auth

data/generators/simple_auth/simple_auth_generator.rb

@@ -0,0 +1,7 @@
+class SimpleAuthGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.file "simple_auth.rb", "config/initializers/simple_auth.rb"
+    end
+  end
+end

data/generators/simple_auth/templates/simple_auth.rb

@@ -0,0 +1,19 @@
+# Use this file to setup SimpleAuth.
+SimpleAuth.setup do |config|
+  # Generate the password hash. The specified block should expected
+  # the plain password and the password hash as block parameters.
+  # config.crypter = proc {|password, salt| Digest::SHA256.hexdigest("#{password}--#{salt}") }
+
+  # Generate the password salt. The specified block should expect
+  # the ActiveRecord instance as block parameter.
+  # config.salt = proc {|r| Digest::SHA256.hexdigest("#{Time.now.to_s}--#{r.email}")}
+
+  # Set which attributes will be used for authentication.
+  config.credentials = [:email, :login]
+
+  # Set the User model that should be used
+  config.model = :user
+
+  # Set the login url
+  config.redirect_to = proc { login_path }
+end

data/init.rb

@@ -0,0 +1 @@
+require "simple_auth"

data/lib/simple_auth.rb

@@ -0,0 +1,18 @@
+require "digest/sha2"
+require "simple_auth/config"
+require "simple_auth/active_record"
+require "simple_auth/session"
+require "simple_auth/version"
+
+module SimpleAuth
+  class NotAuthorized < Exception; end
+end
+
+ActiveRecord::Base.send :include, SimpleAuth::ActiveRecord::InstanceMethods
+ActiveRecord::Base.send :extend, SimpleAuth::ActiveRecord::ClassMethods
+
+ActionController::Base.send :include, SimpleAuth::ActionController::Implementation
+ActionController::Base.send :include, SimpleAuth::ActionController::InstanceMethods
+ActionController::Base.send :extend, SimpleAuth::ActionController::ClassMethods
+
+I18n.load_path += Dir[File.dirname(__FILE__) + "/../config/locales/*.yml"]

data/lib/simple_auth/action_controller.rb

@@ -0,0 +1,81 @@
+module SimpleAuth
+  module ActionController
+    module Implementation
+      def self.included(klass)
+        klass.prepend_before_filter :activate_simple_auth
+        klass.helper_method :current_user, :current_session, :logged_in?
+      end
+    end
+
+    module InstanceMethods
+      private
+        def current_session
+          @current_session ||= SimpleAuth::Session.find
+        end
+
+        def current_user
+          current_session && current_session.record
+        end
+
+        def authorized?
+          true
+        end
+
+        def logged_in?
+          current_user != nil
+        end
+
+        def activate_simple_auth
+          SimpleAuth::Config.controller = self
+        end
+
+        def simple_auth_path(controller, path)
+          path ||= SimpleAuth::Config.redirect_to
+          path = controller.instance_eval(&path) if path.kind_of?(Proc)
+          path
+        end
+    end
+
+    module ClassMethods
+      # Redirect unlogged users to the specified :to path
+      #
+      #   require_logged_user :to => proc { login_path }
+      #   require_logged_user :to => {:controller => "session", :action => "new"}
+      #   require_logged_user :only => [:index], :to => login_path
+      #   require_logged_user :except => [:public], :to => login_path
+      #
+      # You can set :to globally:
+      #
+      #   SimpleAuth::Config.redirect_to = {:controller => "session", :action => "new"}
+      #   SimpleAuth::Config.redirect_to = proc { login_path }
+      def require_logged_user(options = {})
+        before_filter(options.except(:to)) do |c|
+          c.instance_eval do
+            path = simple_auth_path(c, options[:to])
+
+            unless logged_in? && authorized?
+              flash[:warning] = I18n.translate("simple_auth.sessions.need_to_be_logged")
+              session[:return_to] = request.request_uri if request.get?
+              redirect_to path
+            end
+          end
+        end
+      end
+
+      # Redirect logged users to the specified :to path
+      #
+      #   redirect_logged_user :to => proc { login_path }
+      #   redirect_logged_user :to => {:controller => "dashboard"}
+      #   redirect_logged_user :only => [:index], :to => login_path
+      #   redirect_logged_user :except => [:public], :to => login_path
+      def redirect_logged_user(options = {})
+        before_filter(options.except(:to)) do |c|
+          c.instance_eval do
+            path = simple_auth_path(c, options[:to])
+            redirect_to path if logged_in?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_auth/active_record.rb

@@ -0,0 +1,80 @@
+module SimpleAuth
+  module ActiveRecord
+    module InstanceMethods
+      private
+        def encrypt_password
+          self.password_salt = SimpleAuth::Config.salt.call(self)
+          self.password_hash = SimpleAuth::Config.crypter.call(password, password_salt)
+        end
+
+        def erase_password
+          self.password = nil
+          self.password_confirmation = nil
+        end
+
+        def validate_password?
+          new_record? || password.present?
+        end
+    end
+
+    module ClassMethods
+      # Receive a credential and a password and try to authenticate the specified user.
+      # If the credential is valid, then an user is returned; otherwise nil is returned.
+      #
+      #   User.authenticate "johndoe", "test"
+      #   User.authenticate "john@doe.com", "test"
+      def authenticate(credential, password)
+        # Build a hash that will be passed to the finder
+        options = {:conditions => [[], {}]}
+
+        # Iterate each attribute that should be used as credential
+        # and set it to the finder conditions hash
+        SimpleAuth::Config.credentials.each do |attr_name|
+          options[:conditions][0] << "#{attr_name} = :#{attr_name}"
+          options[:conditions][1][attr_name] = credential
+        end
+
+        # Join the attributes in OR query
+        options[:conditions][0] = options[:conditions][0].join(" OR ")
+
+        # Find the record using the conditions we built
+        record = SimpleAuth::Config.model_class.first(options)
+
+        # If no record has been found
+        return nil unless record
+
+        # Compare password
+        return nil unless record.password_hash == SimpleAuth::Config.crypter.call(password, record.password_salt)
+
+        return record
+      end
+
+      # Set virtual attributes, callbacks and acts as a wrapper for
+      # SimpleAuth::Config if a block is provided.
+      #
+      #   class User < ActiveRecord::Base
+      #     has_authentication
+      #   end
+      #
+      #   class User < ActiveRecord::Base
+      #     has_authentication do |config|
+      #       config.credentials = [:email]
+      #     end
+      #   end
+      def has_authentication(&block)
+        attr_accessor :password
+        attr_accessor :password_confirmation
+
+        SimpleAuth.setup(&block)
+
+        before_save :encrypt_password, :if => :validate_password?
+        after_save  :erase_password
+
+        validates_presence_of     :password,              :if => :validate_password?
+        validates_length_of       :password,              :if => :validate_password?, :minimum => 4, :allow_blank => true
+        validates_presence_of     :password_confirmation, :if => :validate_password?
+        validates_confirmation_of :password,              :if => :validate_password?
+      end
+    end
+  end
+end

data/lib/simple_auth/config.rb

@@ -0,0 +1,46 @@
+module SimpleAuth
+  # Add a shortcut to Authorization::Config
+  def self.setup(&block)
+    yield SimpleAuth::Config if block_given?
+  end
+
+  class Config
+    # Generate the password hash. The specified block should expected
+    # the plain password and the password hash as block parameters.
+    cattr_accessor :crypter
+    @@crypter = proc do |password, salt|
+      Digest::SHA256.hexdigest [password, salt].join("--")
+    end
+
+    # Generate the password salt. The specified block should expect
+    # the ActiveRecord instance as block parameter.
+    cattr_accessor :salt
+    @@salt = proc do |record|
+      Digest::SHA256.hexdigest [Time.to_s, ActiveSupport::SecureRandom.hex(32)].join("--")
+    end
+
+    # Set which attributes will be used for authentication.
+    cattr_accessor :credentials
+    @@credentials = [:email, :login]
+
+    # Set the user model
+    cattr_accessor :model
+    @@model = :user
+
+    # Set the current controller object
+    cattr_accessor :controller
+    @@controller = nil
+
+    # Set the login url
+    cattr_accessor :redirect_to
+    @@redirect_to = proc { login_path }
+
+    # Reset session before saving the user session
+    cattr_accessor :reset_session
+    @@reset_session = false
+
+    def self.model_class
+      model.to_s.classify.constantize
+    end
+  end
+end

data/lib/simple_auth/session.rb

@@ -0,0 +1,114 @@
+module SimpleAuth
+  class Session
+    attr_accessor :credential
+    attr_accessor :password
+    attr_accessor :model
+    attr_accessor :controller
+    attr_accessor :record
+    attr_accessor :errors
+
+    class Errors
+      attr_accessor :errors
+
+      def add_to_base(message)
+        @errors << message
+      end
+
+      def initialize
+        @errors = []
+      end
+
+      def on(attr_name)
+        nil
+      end
+
+      def full_messages
+        @errors
+      end
+
+      def empty?
+        @errors.empty?
+      end
+    end
+
+    def self.find
+      session = new
+      session.record = session.model.find_by_id(session.controller.session[:record_id])
+
+      if session.record
+        session
+      else
+        nil
+      end
+    end
+
+    def self.create(options = {})
+      returning new(options) do |session|
+        session.save
+      end
+    end
+
+    def self.create!(options = {})
+      returning new(options) do |session|
+        session.save!
+      end
+    end
+
+    def self.destroy!
+      controller = SimpleAuth::Config.controller
+      controller.session[:record_id] = nil
+      controller.instance_variable_set("@current_user", nil)
+      controller.instance_variable_set("@current_session", nil)
+      true
+    end
+
+    def initialize(options = {})
+      @credential = options[:credential]
+      @password = options[:password]
+      @controller = SimpleAuth::Config.controller
+      @model = SimpleAuth::Config.model_class
+      @errors = Errors.new
+    end
+
+    def new_record?
+      record.nil?
+    end
+
+    def valid?
+      if record
+        true
+      else
+        errors.add_to_base I18n.translate("simple_auth.sessions.invalid_credentials")
+        false
+      end
+    end
+
+    def record
+      @record ||= model.authenticate(credential, password)
+    end
+
+    def save
+      if valid?
+        controller.send(:reset_session) if SimpleAuth::Config.reset_session
+        controller.session[:record_id] = record.id
+      end
+
+      controller.session[:record_id] != nil
+    end
+
+    def save!
+      if valid?
+        save
+      else
+        raise SimpleAuth::NotAuthorized
+      end
+    end
+
+    def destroy
+      @record = nil
+      @credential = nil
+      @password = nil
+      self.class.destroy!
+    end
+  end
+end

data/lib/simple_auth/version.rb

@@ -0,0 +1,8 @@
+module SimpleAuth
+  module Version
+    MAJOR = "0"
+    MINOR = "1"
+    PATCH = "0"
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

data/simple_auth.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simple_auth}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nando Vieira"]
+  s.date = %q{2010-01-04}
+  s.description = %q{When Authlogic & Devise are just too much.
+}
+  s.email = %q{fnando.vieira@gmail.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "app/helpers/simple_auth_helper.rb",
+     "config/locales/en.yml",
+     "config/locales/pt.yml",
+     "generators/simple_auth/USAGE",
+     "generators/simple_auth/simple_auth_generator.rb",
+     "generators/simple_auth/templates/simple_auth.rb",
+     "init.rb",
+     "lib/simple_auth.rb",
+     "lib/simple_auth/action_controller.rb",
+     "lib/simple_auth/active_record.rb",
+     "lib/simple_auth/config.rb",
+     "lib/simple_auth/session.rb",
+     "lib/simple_auth/version.rb",
+     "simple_auth.gemspec",
+     "spec/resources/controllers.rb",
+     "spec/resources/user.rb",
+     "spec/schema.rb",
+     "spec/simple_auth/action_controller_spec.rb",
+     "spec/simple_auth/active_record_spec.rb",
+     "spec/simple_auth/config_spec.rb",
+     "spec/simple_auth/session_spec.rb",
+     "spec/simple_auth/simple_auth_helper_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/fnando/simple_auth}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A simple authentication system for Rails apps}
+  s.test_files = [
+    "spec/resources/controllers.rb",
+     "spec/resources/user.rb",
+     "spec/schema.rb",
+     "spec/simple_auth/action_controller_spec.rb",
+     "spec/simple_auth/active_record_spec.rb",
+     "spec/simple_auth/config_spec.rb",
+     "spec/simple_auth/session_spec.rb",
+     "spec/simple_auth/simple_auth_helper_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/resources/controllers.rb

@@ -0,0 +1,31 @@
+# Add routes
+ActionController::Routing::Routes.add_route "/:controller/:action/:id"
+ActionController::Routing::Routes.add_named_route :login, "/login", :controller => "session", :action => "new"
+ActionController::Routing::Routes.add_named_route :dashboard, "/dashboard", :controller => "dashboard", :action => "index"
+
+class SampleController < ActionController::Base
+end
+
+class SessionController < ActionController::Base
+  redirect_logged_user :to => {:controller => "dashboard"}
+
+  def new
+    @user_session = SimpleAuth::Session.new
+  end
+
+  def create
+    @user_session = SimpleAuth::Session.new(params[:session])
+
+    if @user_session.save
+      redirect_to session.delete(:return_to) || dashboard_path
+    else
+      flash[:warning] = "Invalid login/password."
+      render :new
+    end
+  end
+end
+
+class DashboardController < ActionController::Base
+  def index
+  end
+end

data/spec/resources/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  has_authentication
+end

data/spec/schema.rb

@@ -0,0 +1,5 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users do |t|
+    t.string :email, :login, :password_hash, :password_salt, :username
+  end
+end

data/spec/simple_auth/action_controller_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe SimpleAuth::ActionController, :type => :controller do
+  before do
+    @user = User.create(
+      :login => "johndoe",
+      :email => "john@doe.com",
+      :password => "test",
+      :password_confirmation => "test"
+    )
+  end
+
+  describe "require_logged_user" do
+    controller_name :dashboard
+
+    context "unlogged user" do
+      before do
+        DashboardController.filter_chain.pop if DashboardController.filter_chain.count > 1
+      end
+
+      context "return to" do
+        before do
+          DashboardController.require_logged_user :to => "/login"
+        end
+
+        it "should set return to" do
+          get :index
+          session[:return_to].should == "/dashboard"
+        end
+
+        it "should set warning message" do
+          get :index
+          flash[:warning].should == "You need to be logged"
+        end
+
+        it "should redirect when user is not authorized" do
+          controller.should_receive(:logged_in?).and_return(true)
+          controller.should_receive(:authorized?).and_return(false)
+
+          get :index
+          response.should redirect_to("/login")
+        end
+      end
+
+      it "should be redirected [hash]" do
+        DashboardController.require_logged_user :to => {:controller => "session", :action => "new"}
+
+        get :index
+        response.should redirect_to("/session/new")
+      end
+
+      it "should be redirected [block]" do
+        DashboardController.require_logged_user :to => proc { login_path }
+
+        get :index
+        response.should redirect_to("/login")
+      end
+
+      it "should be redirected [string]" do
+        DashboardController.require_logged_user :to => "/login"
+
+        get :index
+        response.should redirect_to("/login")
+      end
+    end
+
+    context "logged user" do
+      before do
+        session[:record_id] = @user.id
+        get :index
+      end
+
+      it "should render page" do
+        response.should render_template(:index)
+      end
+    end
+  end
+
+  describe "redirect_logged_users" do
+    controller_name :session
+
+    context "unlogged user" do
+      before do
+        get :new
+      end
+
+      it "should render page" do
+        response.should render_template(:new)
+      end
+    end
+
+    context "logged user" do
+      before do
+        session[:record_id] = @user.id
+        get :new
+      end
+
+      it "should be redirected" do
+        response.should redirect_to("/dashboard")
+      end
+    end
+  end
+end

data/spec/simple_auth/active_record_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe SimpleAuth::ActiveRecord do
+  context "new record" do
+    subject { User.new }
+
+    before do
+      subject.should_not be_valid
+    end
+
+    it "should require password" do
+      subject.should have(1).error_on(:password)
+    end
+
+    it "should require password to be at least 4-chars long" do
+      subject.password = "123"
+      subject.should_not be_valid
+      subject.should have(1).error_on(:password)
+    end
+
+    it "should require password confirmation not to be empty" do
+      subject.password_confirmation = ""
+      subject.should have(1).error_on(:password_confirmation)
+    end
+
+    it "should require password confirmation not to be nil" do
+      subject.password_confirmation = nil
+      subject.should have(1).error_on(:password_confirmation)
+    end
+
+    it "should unset password after saving" do
+      subject = User.new(:password => "test", :password_confirmation => "test")
+      subject.save(false)
+      subject.password.should be_nil
+      subject.password_confirmation.should be_nil
+    end
+  end
+
+  context "existing record" do
+    subject {
+      User.new(
+        :email => "john@doe.com",
+        :login => "johndoe",
+        :password => "test",
+        :password_confirmation => "test",
+        :username => "john"
+      )
+    }
+
+    before do
+      subject.save!
+    end
+
+    it "should not require password when it hasn't changed" do
+      subject.login = "john"
+      subject.should be_valid
+    end
+
+    it "should not require password confirmation when it has changed" do
+      subject.password = "newpass"
+      subject.should have(1).error_on(:password_confirmation)
+    end
+
+    it "should authenticate using email" do
+      User.authenticate("john@doe.com", "test").should == subject
+    end
+
+    it "should authenticate using login" do
+      User.authenticate("johndoe", "test").should == subject
+    end
+
+    it "should authenticate using custom attribute" do
+      SimpleAuth::Config.credentials = [:username]
+      User.authenticate("john", "test").should == subject
+    end
+
+    it "should not authenticate using invalid credential" do
+      User.authenticate("invalid", "test").should be_nil
+    end
+
+    it "should not authenticate using wrong password" do
+      User.authenticate("johndoe", "invalid").should be_nil
+    end
+  end
+end

data/spec/simple_auth/config_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe SimpleAuth::Config do
+  it "should yield SimpleAuth::Config class" do
+    SimpleAuth.setup do |config|
+      config.should == SimpleAuth::Config
+    end
+  end
+
+  it "should use [:email, :login] as credential attributes" do
+    SimpleAuth::Config.credentials.should == [:email, :login]
+  end
+
+  it "should use User as default model" do
+    SimpleAuth::Config.model.should == :user
+  end
+
+  specify "crypter should expect 2 block arguments" do
+    SimpleAuth::Config.crypter.arity.should == 2
+  end
+
+  specify "salt should expect 1 block argument" do
+    SimpleAuth::Config.salt.arity.should == 1
+  end
+
+  specify "salt should return a 64-char long salt" do
+    SimpleAuth::Config.salt.call(nil).size.should == 64
+  end
+end

data/spec/simple_auth/session_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe SimpleAuth::Session do
+  before do
+    @user = User.create!(
+      :login => "johndoe",
+      :email => "john@doe.com",
+      :password => "test",
+      :password_confirmation => "test"
+    )
+
+    @session = Hash.new
+    @controller = SampleController.new
+    @controller.session = @session
+
+    SimpleAuth::Config.controller = @controller
+    @user_session = SimpleAuth::Session.new(:credential => "johndoe", :password => "test")
+  end
+
+  context "valid credentials" do
+    before do
+      @user_session.save!
+    end
+
+    it "should return existing session" do
+      @user_session = SimpleAuth::Session.find
+      @user_session.should be_valid
+      @user_session.record.should == @user
+    end
+
+    it "should not be new record" do
+      @user_session.should_not be_new_record
+    end
+
+    it "should find record" do
+      @user_session.record.should == @user
+    end
+
+    it "should be a valid session" do
+      @user_session.should be_valid
+    end
+
+    it "should set record_id on session" do
+      @session[:record_id].should == @user.id
+    end
+
+    it "should be saved" do
+      @user_session.save.should be_true
+    end
+
+    it "should automatically save session when calling create!" do
+      @user_session = SimpleAuth::Session.create!(:credential => "johndoe", :password => "test")
+      @user_session.should be_valid
+      @user_session.record.should == @user
+      @session[:record_id].should == @user.id
+    end
+
+    it "should reset session" do
+      SimpleAuth::Config.reset_session = true
+      SimpleAuth::Config.controller.should_receive(:reset_session)
+      @user_session.save
+    end
+
+    it "should destroy session" do
+      @user_session.destroy.should be_true
+      @user_session.record.should be_nil
+      @session[:record_id].should be_nil
+    end
+  end
+
+  context "invalid credentials" do
+    before do
+      @user_session.credential = "invalid"
+      @user_session.save
+    end
+
+    it "should be new record" do
+      SimpleAuth::Session.new.should be_new_record
+      @user_session.should be_new_record
+    end
+
+    it "should have error message" do
+      @user_session.errors.full_messages[0].should == "Invalid username or password"
+    end
+
+    it "should not return error messages for attributes" do
+      @user_session.errors.on(:credential).should be_nil
+      @user_session.errors.on(:password).should be_nil
+    end
+
+    it "should have errors" do
+      @user_session.errors.should_not be_empty
+    end
+
+    it "should not find existing session" do
+      SimpleAuth::Session.find.should be_nil
+    end
+
+    it "should not find record" do
+      @user_session.record.should be_nil
+    end
+
+    it "should not be a valid session" do
+      @user_session.should_not be_valid
+    end
+
+    it "should unset record_id from session" do
+      @session[:record_id].should be_nil
+    end
+
+    it "should not be saved" do
+      @user_session.save.should be_false
+    end
+
+    it "should raise error with save!" do
+      doing { @user_session.save! }.should raise_error(SimpleAuth::NotAuthorized)
+    end
+
+    it "should raise error with create!" do
+      doing { SimpleAuth::Session.create!({}) }.should raise_error(SimpleAuth::NotAuthorized)
+    end
+  end
+
+  context "destroying valid session" do
+    before do
+      @user_session.save!
+      @user_session.destroy
+    end
+
+    it "should unset record_id from session" do
+      @session[:record_id].should be_nil
+    end
+
+    it "should unset current_user instance variable" do
+      SimpleAuth::Config.controller.send(:current_user).should be_nil
+      SimpleAuth::Config.controller.instance_variable_get("@current_user").should be_nil
+      SimpleAuth::Config.controller.instance_variable_get("@current_session").should be_nil
+    end
+  end
+end

data/spec/simple_auth/simple_auth_helper_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe SimpleAuthHelper, :type => :helper do
+  it "should render block when user is logged" do
+    helper.should_receive(:logged_in?).and_return(true)
+    helper.when_logged { "logged" }.should == "logged"
+  end
+
+  it "should not render block when user is unlogged" do
+    helper.should_receive(:logged_in?).and_return(false)
+    helper.when_logged { "logged" }.should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# Load application RSpec helper
+begin
+  require File.dirname(__FILE__) + "/../../../../spec/spec_helper"
+rescue LoadError
+  puts "Your application hasn't been bootstraped with RSpec.\nI'll do it on my own!\n\n"
+  system "cd '#{File.dirname(__FILE__) + "/../../../../"}' && script/generate rspec"
+  puts "\n\nRun `rake spec` again."
+  exit
+end
+
+# Establish connection with in memory SQLite 3 database
+ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
+
+# Load database schema
+load File.dirname(__FILE__) + "/schema.rb"
+
+# Create an alias for lambda
+alias :doing :lambda
+
+# Load resources
+require File.dirname(__FILE__) + "/resources/user"
+require File.dirname(__FILE__) + "/resources/controllers"
+
+# Restore default configuration
+Spec::Runner.configure do |config|
+  config.before :each do
+    load File.dirname(__FILE__) + "/../lib/simple_auth/config.rb"
+    SimpleAuth::Config.model = :user
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: simple_auth
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nando Vieira
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-04 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: |
+  When Authlogic & Devise are just too much.
+
+email: fnando.vieira@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION
+- app/helpers/simple_auth_helper.rb
+- config/locales/en.yml
+- config/locales/pt.yml
+- generators/simple_auth/USAGE
+- generators/simple_auth/simple_auth_generator.rb
+- generators/simple_auth/templates/simple_auth.rb
+- init.rb
+- lib/simple_auth.rb
+- lib/simple_auth/action_controller.rb
+- lib/simple_auth/active_record.rb
+- lib/simple_auth/config.rb
+- lib/simple_auth/session.rb
+- lib/simple_auth/version.rb
+- simple_auth.gemspec
+- spec/resources/controllers.rb
+- spec/resources/user.rb
+- spec/schema.rb
+- spec/simple_auth/action_controller_spec.rb
+- spec/simple_auth/active_record_spec.rb
+- spec/simple_auth/config_spec.rb
+- spec/simple_auth/session_spec.rb
+- spec/simple_auth/simple_auth_helper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/fnando/simple_auth
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A simple authentication system for Rails apps
+test_files: 
+- spec/resources/controllers.rb
+- spec/resources/user.rb
+- spec/schema.rb
+- spec/simple_auth/action_controller_spec.rb
+- spec/simple_auth/active_record_spec.rb
+- spec/simple_auth/config_spec.rb
+- spec/simple_auth/session_spec.rb
+- spec/simple_auth/simple_auth_helper_spec.rb
+- spec/spec_helper.rb