toretore-simple_authentication 0.1.2 → 0.1.3

data/app/controllers/logins_controller.rb

@@ -0,0 +1,6 @@
+class LoginsController < ApplicationController
+
+  include SimpleAuthentication::ControllerMethods::Logins
+  include SimpleAuthentication::ControllerMethods::Logins::Behavior
+
+end

data/app/models/user.rb

@@ -0,0 +1,5 @@
+class User < ActiveRecord::Base
+
+  include SimpleAuthentication::ModelMethods::User
+
+end

data/app/views/logins/new.html.erb

@@ -0,0 +1,8 @@
+<h2><%= t('simple_authentication.login_title') %></h2>
+
+<ul class="authenticators">
+  <% for authenticator in @authenticators -%>
+    <li><%= link_to t(:link, :scope => [:simple_authentication, :authenticators, authenticator.identifier]),
+      new_login_with_authenticator_url(:authenticator => authenticator.identifier) %></li>
+  <% end -%>
+</ul>

data/app/views/logins/show.html.erb

@@ -0,0 +1,5 @@
+<p>
+  You're logged in as <strong><%= h(@user.display_name) %></strong>.
+</p>
+
+<%= button_to "Log out", login_url, :method => :delete %>

data/config/locales/simple_authentication.yml

@@ -0,0 +1,7 @@
+en:
+  simple_authentication:
+    login_required: You must be logged in to view this page
+    logout_required: You must be logged out to view this page
+    login_successful: "You're logged in"
+    login_failed: Login failed
+    login_title: Log in

data/config/routes.rb

@@ -0,0 +1,4 @@
+ActionController::Routing::Routes.draw do |map|
+  map.resource :login
+  map.new_login_with_authenticator 'login/:authenticator', :controller => 'logins', :action => 'new'
+end

data/generators/simple_authentication/USAGE

@@ -0,0 +1,5 @@
+Description:
+  Create user migration
+
+Example:
+    ./script/generate simple_authentication --migration User

data/generators/simple_authentication/simple_authentication_generator.rb

@@ -0,0 +1,37 @@
+class SimpleAuthenticationGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.migration_template "model:migration.rb", "db/migrate", :assigns => simple_auth_assigns,
+        :migration_file_name => "create_#{custom_file_name}" if options[:migration]
+    end
+  end
+
+private
+
+  def custom_file_name
+    name = class_name.underscore.downcase
+    name = name.pluralize if ActiveRecord::Base.pluralize_table_names
+    name
+  end
+
+  def simple_auth_assigns
+    {
+      :migration_name => "Create#{custom_file_name.camelize}",
+      :table_name => custom_file_name,
+      :attributes => simple_auth_attributes
+    }
+  end
+
+  def simple_auth_attributes
+    returning attributes.dup do |attributes|
+      {"name" => "string", "email" => "string"}.each do |name, type|
+        attributes << Rails::Generator::GeneratedAttribute.new(name, type) unless attributes.any?{|a| a.name == name }
+      end
+    end
+  end
+
+  def add_options!(opt)
+    opt.on('--migration', 'Create migration'){|v| options[:migration] = true }
+  end
+
+end

data/lib/simple_authentication.rb

@@ -0,0 +1,6 @@
+require "simple_authentication/authenticator"
+require "simple_authentication/controller_methods"
+require "simple_authentication/model_methods"
+
+ActionController::Base.send(:include, SimpleAuthentication::ControllerMethods::Application)
+I18n.load_path.unshift(File.join(File.dirname(__FILE__), '..', 'config', 'locales', 'simple_authentication.yml'))

data/lib/simple_authentication/authenticator.rb

@@ -0,0 +1,57 @@
+module SimpleAuthentication
+
+
+  class Authenticator
+
+    def initialize(controller)
+      @controller = controller
+    end
+
+    def authenticate
+      raise NotImplementedError
+    end
+
+    def authentication_possible?
+      false
+    end
+
+    def authenticate_if_possible
+      return false unless authentication_possible?
+      authenticate
+    end
+
+  private
+
+    def controller
+      @controller
+    end
+
+    def params
+      controller.params
+    end
+
+
+    def self.authenticators
+      @authenticators ||= []
+    end
+
+
+    def self.inherited(klass)
+      authenticators << klass
+    end
+
+  public
+
+    def self.identifier
+      name.split('::').last.gsub(/Authenticator$/, '').underscore
+    end
+
+    def self.authenticator_for(identifier)
+      authenticators.detect{|a| a.identifier == identifier }
+    end
+
+
+  end
+
+
+end

data/lib/simple_authentication/controller_methods.rb

@@ -0,0 +1,157 @@
+module SimpleAuthentication
+
+
+  module ControllerMethods
+
+
+    module Application
+
+
+      def self.included(controller)
+        [:logged_in?, :logged_out?, :current_user].each do |m|
+          controller.helper_method m
+        end
+      end
+
+
+      def current_user
+        @_current_user ||= User.find_by_id(session[:current_user_id])
+      end
+
+      def logged_in?
+        !!current_user
+      end
+
+      def logged_out?
+        !logged_in?
+      end
+
+
+    private
+
+      def current_user=(user)
+        @_current_user = user
+        session[:current_user_id] = user && user.id
+      end
+
+
+      def require_login
+        unless logged_in?
+          flash[:error] = I18n.t('simple_authentication.login_required')
+          redirect_to new_login_url
+        end
+      end
+
+      def require_logout
+        unless logged_out?
+          flash[:error] = I18n.t('simple_authentication.logout_required')
+          redirect_to login_url
+        end
+      end
+
+
+    end
+
+
+    module Logins
+
+
+      def show
+        @user = current_user
+      end
+
+
+      #If there is only one authenticator installed or if one has been specified,
+      #this will render its login form.
+      #
+      #If there is more than one installed and none has been specified, it will
+      #list all authenticators as links to their login forms.
+      def new
+        if authenticator
+          send(authenticator.identifier) if respond_to?(authenticator.identifier)
+          render :action => authenticator.identifier
+        else
+          @authenticators = SimpleAuthentication::Authenticator.authenticators
+        end
+      end
+
+
+      #Create a login - aka log in the user
+      #
+      #An authenticator must be specified for authentication to continue. The
+      #authenticator will receive the controller as its only parameter and either
+      #
+      # * respond with :ok, signalling that it takes care of everything
+      # * or, if the authentication was successful, return the User that
+      #   was authenticated. current_user will then be set to this user.
+      # * or, if the authentication failed, return nil or false
+      def create
+        if params[:authenticator]
+          if authenticator && user = authenticator.new(self).authenticate
+            unless user == :ok#Authenticator doesn't want any help
+              self.current_user = user
+              authentication_successful
+            end
+          elsif authenticator
+            #First, see if the authenticator has defined a message of its own
+            message = I18n.t(:login_failed, :default => "##not found##",#This is hacky
+              :scope => [:simple_authentication, :authenticators, authenticator.identifier])
+            #If not, use default
+            message = I18n.t('simple_authentication.login_failed') if message == "##not found##"
+
+            authentication_failed message
+          else
+            authentication_failed
+          end
+        else
+          authentication_failed
+        end
+      end
+
+
+      #Destroy the login - aka "log out"
+      def destroy
+        self.current_user = nil
+        redirect_to new_login_url
+      end
+
+
+    private
+
+      def authenticator
+        @authenticator ||= SimpleAuthentication::Authenticator.authenticators.size == 1 ?
+          SimpleAuthentication::Authenticator.authenticators.first :
+          SimpleAuthentication::Authenticator.authenticator_for(params[:authenticator])
+      end
+
+
+      def authentication_successful(message = I18n.t('simple_authentication.login_successful'))
+        flash[:notice] = message
+        redirect_to login_url
+      end
+
+      def authentication_failed(message = I18n.t('simple_authentication.login_failed'))
+        flash[:error] = message
+        redirect_to params[:authenticator].blank? ?
+          new_login_url :
+          new_login_with_authenticator_url(:authenticator => authenticator.identifier)
+      end
+
+
+      module Behavior
+
+        def self.included(controller)
+          controller.before_filter :require_login, :except => [:new, :create]
+          controller.before_filter :require_logout, :only => [:new, :create]
+        end
+
+      end
+
+
+    end
+
+
+  end
+
+
+end

data/lib/simple_authentication/model_methods.rb

@@ -0,0 +1,61 @@
+module SimpleAuthentication
+  module ModelMethods
+    module User
+
+      def self.model_classes
+        @model_classes ||= []
+      end
+
+      #Keep a track of modules/classes that include this module
+      def self.included(m)
+        model_classes << m
+        m.extend ClassMethods
+      end
+
+      #When another module is included in this one,
+      #include that module in all modules/classes that include this module
+      #This way if another module is included in this one after this module
+      #has been included elsewhere, those other classes will still have access
+      #to the methods in the included module. Example:
+      #
+      #User.include(SimpleAuthentication::ModelMethods::User)
+      #SimpleAuthentication::ModelMethods::User.include(OtherModule)
+      #
+      #Normally, User wouldn't have access to OtherModule's methods,
+      #but we're passing them on. This way, other plugins can add
+      #methods to User without having to load/touch it directly.
+      def self.include(m)
+        self.model_classes.each{|c| c.send(:include, m) }
+        super
+      end
+
+      def display_name
+        name
+      end
+
+
+      #Class methods for User
+      #
+      #Methods included here are automatically added to User as class methods
+      module ClassMethods
+
+        def self.model_classes
+          @model_classes ||= []
+        end
+
+        #Keep track of model classes (in practise this is just User)
+        def self.extended(m)
+          model_classes << m
+        end
+
+        #When methods are included here, add them to User's eigenclass
+        def self.include(m)
+          model_classes.each{|c| c.extend m }
+          super
+        end
+
+      end
+
+    end
+  end
+end

data/rails/init.rb

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

data/rails/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/rails/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

data/tasks/simple_authentication_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :simple_authentication do
+#   # Task goes here
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: toretore-simple_authentication
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Tore Darell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-09 00:00:00 -07:00
+date: 2009-03-16 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -21,8 +21,31 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- lib/simple_authentication.rb
+- lib/simple_authentication
+- lib/simple_authentication/authenticator.rb
+- lib/simple_authentication/controller_methods.rb
+- lib/simple_authentication/model_methods.rb
+- rails/uninstall.rb
+- rails/install.rb
+- rails/init.rb
+- config/routes.rb
+- config/locales
+- config/locales/simple_authentication.yml
+- app/views
+- app/views/logins
+- app/views/logins/new.html.erb
+- app/views/logins/show.html.erb
+- app/controllers
+- app/controllers/logins_controller.rb
+- app/models
+- app/models/user.rb
+- generators/simple_authentication
+- generators/simple_authentication/simple_authentication_generator.rb
+- generators/simple_authentication/USAGE
+- generators/simple_authentication/templates
+- tasks/simple_authentication_tasks.rake
 has_rdoc: false
 homepage: http://github.com/toretore/simple_authentication
 post_install_message: