parlement 0.14 → 0.17

data/vendor/plugins/login_engine/CHANGELOG

@@ -1,22 +0,0 @@
-= v1.0.2
-* Added version
-* Removed errant requires no longer needed (murray.steele@gmail.com, Ticket #156, Ticket #157, Ticket #158)
-# Removed documentation/rake tasks that refer the schema.rb (Ticket #155)
-# Verified cannot be assigned via URL parameters. If more security is required, users should override the signup action itself (Ticket #169)
-# Minor view/flash message cleanup
-# Authentication by token now respects primary key prefixes (Ticket #140)
-
-= v1.0.1
- * Added CHANGELOG
- * Changed wording for when password forgotten to 'reset', rather than 'retrieve'. (snowblink@gmail.com)
- * Fixed new location of engines testing extensions. (lazyatom@gmail.com)
- * Removed schema.db from Login Engine; migrations should be used instead. (snowblink@gmail.com)
- * Updated User Controller tests to parse the user_id and email out of the URL in the email body. (snowblink@gmail.com)
- * Ticket #89 (lazyatom@gmail.com) User creation halts the after_save callback chain.
- * Ticket #97 (dcorbin@machturtle.com) The forgotten_password view generates invalid HTML
- * Ticket #112 (segabor@gmail.com) Authentication system will break even on successful login
- * Added simple email validation to the User model. (snowblink@gmail.com)
-   This should also take care of the unit test failures detailed in Ticket #114 (morris@wolfman.com)
- * Ticket #118 (augustz@augustz.com) SVN source for login_engine not found
- * Ticket #119 (Goynang) Unit tests for engines fail after default install
- * Ticket #126 (lazyatom@gmail.com) Add install.rb to login engine

data/vendor/plugins/login_engine/README

@@ -1,344 +0,0 @@
-= Before we start
-
-This is a Rails Engine version of the Salted Login Generator, a most excellent login system which is sufficient for most simple cases. For the most part, this code has not been altered from its generator form, with the following notable exceptions
-
-* Localization has been removed.
-* The 'welcome' page has been changed to the 'home' page
-* A few new functions have been thrown in
-* It's... uh.... a Rails Engine now ;-)
-
-However, what I'm trying to say is that 99.9999% of the credit for this should go to Joe Hosteny, Tobias Luetke (xal) and the folks that worked on the original Salted Login generator code. I've just wrapped it into something runnable with the Rails Engine system.
-
-Please also bear in mind that this is a work in progress, and things like testing are wildly up in the air... but they will fall into place very soon. And now, on with the show.
-
-
-= Installation
-
-Installing the Login Engine is fairly simple.
-
-Your options are:
-  1.  Install as a rails plugin:
-      $ script/plugin install login_engine
-  2.  Use svn:externals
-      $ svn propedit svn:externals vendor/plugins
-
-      You can choose to use the latest stable release:
-          login_engine http://svn.rails-engines.org/plugins/login_engine
-
-      Or a tagged release (recommended for releases of your code):
-          login_engine http://svn.rails-engines.org/logine_engine/tags/<TAGGED_RELEASE>
-
-There are a few configuration steps that you'll need to take to get everything running smoothly. Listed below are the changes to your application you will need to make.
-
-=== Setup your Rails application
-
-Edit your <tt>database.yml</tt>, most importantly! You might also want to move <tt>public/index.html</tt> out of the way, and set up some default routes in <tt>config/routes.rb</tt>.
-
-=== Add configuration and start engine
-
-Add the following to the bottom of environment.rb:
-
-  module LoginEngine
-    config :salt, "your-salt-here"
-  end
-
-  Engines.start :login
-  
-You'll probably want to change the Salt value to something unique. You can also override any of the configuration values defined at the top of lib/user_system.rb in a similar way. Note that you don't need to start the engine with <tt>Engines.start :login_engine</tt> - instead, <tt>:login</tt> (or any name) is sufficient if the engine is a directory named <some-name>_engine.
-
-
-=== Add the filters
-
-Next, edit your <tt>app/controllers/application.rb</tt> file. The beginning of your <tt>ApplicationController</tt> should look something like this:
-
-  require 'login_engine'
-
-  class ApplicationController < ActionController::Base
-    include LoginEngine
-    helper :user
-    model :user
-    
-    before_filter :login_required
-
-If you don't want ALL actions to require a login, you need to read further below to learn how to restrict only certain actions. 
-
-Add the following to your ApplicationHelper:
-
-  module ApplicationHelper
-    include LoginEngine
-  end
-
-This ensures that the methods to work with users in your views are available
-
-=== Set up ActionMailer
-
-If you want to disable email functions within the Login Engine, simple set the :use_email_notification config flag to false in your environment.rb file:
-
-  module LoginEngine
-    
-    #  ... other options...
-    config :use_email_notification, false
-
-  end
-
-You should note that retrieving forgotten passwords automatically isn't possible when the email functions are disabled. Instead, the user is presented with a message instructing them to contact the system administrator
-
-If you wish you use email notifications and account creation verification, you must properly configure ActionMailer for your mail settings. For example, you could add the following in config/environments/development.rb (for a .Mac account, and with your own username and password, obviously):
-
-ActionMailer::Base.server_settings = {
-  :address => "smtp.mac.com",
-  :port => 25,
-  :domain => "smtp.mac.com",
-  :user_name => "<your user name here>",
-  :password => "<your password here>",
-  :authentication => :login
-}
-
-You'll need to configure it properly so that email can be sent. One of the easiest ways to test your configuration is to temporarily reraise exceptions from the signup method (so that you get the actual mailer exception string). In the rescue statement, put a single "raise" statement in. Once you've debugged any setting problems, remove that statement to get the proper flash error handling back.
-
-
-=== Create the DB schema
-
-After you have done the modifications the the ApplicationController and its helper, you can import the user model into the database. Migration information in login_engine/db/migrate/. 
-
-You *MUST* check that these files aren't going to interfere with anything in your application. 
-
-You can change the table name used by adding
-
-  module LoginEngine
-    
-    #  ... other options...
-    config :user_table, "your_table_name"
-
-  end
-
-...to the LoginEngine configuration in <tt>environment.rb</tt>. Then run from the root of your project:
-
-  rake db:migrate:engines ENGINE=login
-
-to import the schema into your database.
-
-
-== Include stylesheets
-
-If you want the default stylesheet, add the following line to your layout:
-
-  <%= engine_stylesheet 'login_engine' %>
-  
-... somewhere in the <head> section of your HTML layout file.
-
-== Integrate flash messages into your layout
-
-LoginEngine does not display any flash messages in the views it contains, and thus you must display them yourself. This allows you to integrate any flash messages into your existing layout. LoginEngine adheres to the emerging flash usage standard, namely:
-
-* :warning - warning (failure) messages
-* :notice - success messages
-* :message - neutral (reminder, informational) messages
-
-This gives you the flexibility to theme the different message classes separately. In your layout you should check for and display flash[:warning], flash[:notice] and flash[:message]. For example:
-
-  <% for name in [:notice, :warning, :message] %>
-    <% if flash[name] %>
-      <%= "<div id=\"#{name}\">#{flash[name]}</div>" %>
-    <% end %>
-  <% end %>
-
-Alternately, you could look at using the flash helper plugin (available from https://opensvn.csie.org/traccgi/flash_helper_plugin/trac.cgi/), which supports the same naming convention.
-
-
-= How to use the Login Engine 
-
-Now you can go around and happily add "before_filter :login_required" to the controllers which you would like to protect. 
-
-After integrating the login system with your rails application navigate to your new controller's signup method. There you can create a new account. After you are done you should have a look at your DB. Your freshly created user will be there but the password will be a sha1 hashed 40 digit mess. I find this should be the minimum of security which every page offering login & password should give its customers. Now you can move to one of those  controllers which you protected with the before_filter :login_required snippet. You will automatically be re-directed to your freshly created login controller and you are asked for a password. After entering valid account data you will be taken back to the controller which you requested earlier. Simple huh?
-
-=== Protection using <tt>before_filter</tt>
-
-Adding the line <tt>before_filter :login_required</tt> to your <tt>app/controllers/application.rb</tt> file will protect *all* of your applications methods, in every controller. If you only want to control access to specific controllers, remove this line from <tt>application.rb</tt> and add it to the controllers that you want to secure.
-
-Within individual controllers you can restrict which methods the filter runs on in the usual way:
-
-       before_filter :login_required, :only => [:myaccount, :changepassword]
-       before_filter :login_required, :except => [:index]
-
-=== Protection using <tt>protect?()</tt>
-
-Alternatively, you can leave the <tt>before_filter</tt> in the global <tt>application.rb</tt> file, and control which actions are restricted in individual controllers by defining a <tt>protect?()</tt> method in that controller.
-
-For instance, in the <tt>UserController</tt> we want to allow everyone access to the 'login', 'signup' and 'forgot_password' methods (otherwise noone would be able to access our site!). So a <tt>protect?()</tt> method is defined in <tt>user_controller.rb</tt> as follows:
-
-  def protect?(action)
-    if ['login', 'signup', 'forgot_password'].include?(action)
-      return false
-    else
-      return true
-    end
-  end
-
-Of course, you can override this Engine behaviour in your application - see below.
-
-== Configuration
-
-The following configuration variables are set in lib/login_engine.rb. If you wish to override them, you should set them BEFORE calling Engines.start (it is possible to set them after, but it's simpler to just do it before. Please refer to the Engine documentation for the #config method for more information).
-
-For example, the following might appear at the bottom of /config/environment.rb:
-
-  module LoginEngine
-    config :salt, 'my salt'
-    config :app_name, 'My Great App'
-    config :app_url, 'http://www.wow-great-domain.com'
-  end
-  
-  Engines.start
-
-=== Configuration Options
-
-+email_from+:: The email from which registration/administration emails will appear to 
-               come from. Defaults to 'webmaster@your.company'.
-+admin_email+:: The email address users are prompted to contact if passwords cannot
-                be emailed. Defaults to 'webmaster@your.company'.
-+app_url+:: The URL of the site sent to users for signup/forgotten passwords, etc.
-            Defaults to 'http://localhost:3000/'.
-+app_name+:: The application title used in emails. Defaults to 'TestApp'.
-+mail_charset+:: The charset used in emails. Defaults to 'utf-8'.
-+security_token_life_hours+:: The life span of security tokens, in hours. If a security
-                              token is older than this when it is used to try and authenticate
-                              a user, it will be discarded. In other words, the amount of time
-                              new users have between signing up and clicking the link they
-                              are sent. Defaults to 24 hours.
-+two_column_input+:: If true, forms created with the UserHelper#form_input method will
-                     use a two-column table. Defaults to true.
-+changeable_fields+:: An array of fields within the user model which the user
-                      is allowed to edit. The Salted Hash Login generator documentation
-                      states that you should NOT include the email field in this
-                      array, although I am not sure why. Defaults to +[ 'firstname', 'lastname' ]+.
-+delayed_delete+::  Set to true to allow delayed deletes (i.e., delete of record
-                    doesn't happen immediately after user selects delete account,
-                    but rather after some expiration of time to allow this action
-                    to be reverted). Defaults to false.
-+delayed_delete_days+:: The time delay used for the 'delayed_delete' feature. Defaults to
-                        7 days.
-+user_table+:: The table to store User objects in. Defaults to "users" (or "user" if
-               ActiveRecord pluralization is disabled).
-+use_email_notification+:: If false, no emails will be sent to the user. As a consequence,
-                           users who signup are immediately verified, and they cannot request
-                           forgotten passwords. Defaults to true.
-+confirm_account+:: An overriding flag to control whether or not user accounts must be
-                    verified by email. This overrides the +user_email_notification+ flag.
-                    Defaults to true.
-
-== Overriding controllers and views
-
-The standard home page is almost certainly not what you want to present to your users. Because this login system is a Rails Engine, overriding the default behaviour couldn't be simpler. To change the RHTML template shown for the <tt>home</tt> action, simple create a new file in <tt>RAILS_ROOT/app/views/user/home.rhtml</tt> (you'll probably need to create the directory <tt>user</tt> at the same time). This new view file will be used instead of the one provided in the Login Engine. Easy!
-
-
-== Tips & Tricks
-
-How do I...
-
-  ... access the user who is currently logged in
-
-  A: You can get the user object from the session using session[:user]
-     Example: 
-       Welcome <%= session[:user].name %>
-
-    You can also use the 'current_user' method provided by UserHelper:
-    Example:
-      Welcome <%= current_user.name %>
-
-
-  ... restrict access to only a few methods? 
-  
-  A: Use before_filters build in scoping. 
-     Example: 
-       before_filter :login_required, :only => [:myaccount, :changepassword]
-       before_filter :login_required, :except => [:index]
-     
-  ... check if a user is logged-in in my views?
-  
-  A: session[:user] will tell you. Here is an example helper which you can use to make this more pretty:
-     Example: 
-       def user?
-         !session[:user].nil?
-       end
-
-  ... return a user to the page they came from before logging in?
-
-  A: The user will be send back to the last url which called the method "store_location"
-     Example:
-       User was at /articles/show/1, wants to log in.
-       in articles_controller.rb, add store_location to the show function and
-       send the user to the login form. 
-       After he logs in he will be send back to /articles/show/1
-
-You can find more help at http://wiki.rubyonrails.com/rails/show/SaltedLoginGenerator
-
-== Troubleshooting
-
-One of the more common problems people have seen is that after verifying an account by following the emailed URL, they are unable to login via the normal login method since the verified field is not properly set in the user model's row in the DB.
-
-The most common cause of this problem is that the DB and session get out of sync. In particular, it always happens for me after recreating the DB if I have run the server previously. To fix the problem, remove the /tmp/ruby* session files (from wherever they are for your installation) while the server is stopped, and then restart. This usually is the cause of the problem.
-
-= Notes
-
-=== Database Schemas & Testing
-
-Currently, since not all databases appear to support structure cloning, the tests will load the entire schema into your test database, potentially blowing away any other test structures you might have. If this presents an issue for your application, comment out the line in test/test_helper.rb
-
-
-= Database Schema Details
-
-You need a database table corresponding to the User model. This is provided as a Rails Schema file, but the schema is presented below for information. Note the table type for MySQL. Whatever DB you use, it must support transactions. If it does not, the functional tests will not work properly, nor will the application in the face of failures during certain DB creates and updates.
-
-  mysql syntax:
-  CREATE TABLE users (
-    id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
-    login VARCHAR(80) NOT NULL,
-    salted_password VARCHAR(40) NOT NULL,
-    email VARCHAR(60) NOT NULL,
-    firstname VARCHAR(40),
-    lastname VARCHAR(40),
-    salt CHAR(40) NOT NULL,
-    verified INT default 0,
-    role VARCHAR(40) default NULL,
-    security_token CHAR(40) default NULL,
-    token_expiry DATETIME default NULL,
-    deleted INT default 0,
-    delete_after DATETIME default NULL
-  ) TYPE=InnoDB DEFAULT CHARSET=utf8;
-
-  postgres:
-  CREATE TABLE "users" (
-    id SERIAL PRIMARY KEY
-    login VARCHAR(80) NOT NULL,
-    salted_password VARCHAR(40) NOT NULL,
-    email VARCHAR(60) NOT NULL,
-    firstname VARCHAR(40),
-    lastname VARCHAR(40),
-    salt CHAR(40) NOT NULL,
-    verified INT default 0,
-    role VARCHAR(40) default NULL,
-    security_token CHAR(40) default NULL,
-    token_expiry TIMESTAMP default NULL,
-    deleted INT default 0,
-    delete_after TIMESTAMP default NULL
-  ) WITH OIDS;
-
-  sqlite:
-  CREATE TABLE 'users' (
-    id INTEGER PRIMARY KEY,
-    login VARCHAR(80) NOT NULL,
-    salted_password VARCHAR(40) NOT NULL,
-    email VARCHAR(60) NOT NULL,
-    firstname VARCHAR(40),
-    lastname VARCHAR(40),
-    salt CHAR(40) NOT NULL,
-    verified INT default 0,
-    role VARCHAR(40) default NULL,
-    security_token CHAR(40) default NULL,
-    token_expiry DATETIME default NULL,
-    deleted INT default 0,
-    delete_after DATETIME default NULL
-  );
-
-Of course your user model can have any amount of extra fields. This is just a starting point.

data/vendor/plugins/login_engine/app/controllers/user_controller.rb

@@ -1,262 +0,0 @@
-class UserController < ApplicationController
-  # echarp
-  #model   :user
-
-  # Override this function in your own application to define a custom home action.
-  def home
-    if user?
-      @fullname = "#{current_user.firstname} #{current_user.lastname}"
-    else
-      @fullname = "Not logged in..."
-    end # this is a bit of a hack since the home action is used to verify user
-        # keys, where noone is logged in. We should probably create a unique
-        # 'validate_key' action instead.
-  end
-
-  # The action used to log a user in. If the user was redirected to the login page
-  # by the login_required method, they should be sent back to the page they were
-  # trying to access. If not, they will be sent to "/user/home".
-  def login
-    return if generate_blank
-    @user = User.new(params[:user])
-    if session[:user] = User.authenticate(params[:user][:login], params[:user][:password])
-      session[:user].logged_in_at = Time.now
-      session[:user].save
-      flash[:notice] = 'Login successful'
-      redirect_to_stored_or_default :action => 'home'
-    else
-      @login = params[:user][:login]
-      flash.now[:warning] = 'Login unsuccessful'
-    end
-  end
-
-  # Register as a new user. Upon successful registration, the user will be sent to
-  # "/user/login" to enter their details.
-  def signup
-    return if generate_blank
-    params[:user].delete('form')
-    params[:user].delete('verified') # you CANNOT pass this as part of the request
-    @user = User.new(params[:user])
-    begin
-      User.transaction(@user) do
-        @user.new_password = true
-        unless LoginEngine.config(:use_email_notification) and LoginEngine.config(:confirm_account)
-          @user.verified = 1
-        end
-        if @user.save
-          key = @user.generate_security_token
-          url = url_for(:action => 'home', :user_id => @user.id, :key => key)
-          flash[:notice] = 'Signup successful!'
-          if LoginEngine.config(:use_email_notification) and LoginEngine.config(:confirm_account)
-            UserNotify.deliver_signup(@user, params[:user][:password], url)
-            flash[:notice] << ' Please check your registered email account to verify your account registration and continue with the login.'
-          else
-            flash[:notice] << ' Please log in.'
-          end
-          redirect_to :action => 'login'
-        end
-      end
-    rescue Exception => e
-      flash.now[:notice] = nil
-      flash.now[:warning] = 'Error creating account: confirmation email not sent'
-      logger.error "Unable to send confirmation E-Mail:"
-      logger.error e
-    end
-  end
-
-  def logout
-    session[:user] = nil
-    redirect_to :action => 'login'
-  end
-
-  def change_password
-    return if generate_filled_in
-    if do_change_password_for(@user)
-      # since sometimes we're changing the password from within another action/template...
-      #redirect_to :action => params[:back_to] if params[:back_to]
-      redirect_back_or_default :action => 'change_password'
-    end
-  end
-
-  protected
-    def do_change_password_for(user)
-      begin
-        User.transaction(user) do
-          user.change_password(params[:user][:password], params[:user][:password_confirmation])
-          if user.save
-            if LoginEngine.config(:use_email_notification)
-              UserNotify.deliver_change_password(user, params[:user][:password])
-              flash[:notice] = "Updated password emailed to #{@user.email}"
-            else
-              flash[:notice] = "Password updated."
-            end
-            return true
-          else
-            flash[:warning] = 'There was a problem saving the password. Please retry.'
-            return false
-          end
-        end
-      rescue
-        flash[:warning] = 'Password could not be changed at this time. Please retry.'
-      end
-    end
-    
-  public
-
-
-  def forgot_password
-    # Always redirect if logged in
-    if user?
-      flash[:message] = 'You are currently logged in. You may change your password now.'
-      redirect_to :action => 'change_password'
-      return
-    end
-
-    # Email disabled... we are unable to provide the password
-    if !LoginEngine.config(:use_email_notification)
-      flash[:message] = "Please contact the system admin at #{LoginEngine.config(:admin_email)} to reset your password."
-      redirect_back_or_default :action => 'login'
-      return
-    end
-
-    # Render on :get and render
-    return if generate_blank
-
-    # Handle the :post
-    if params[:user][:email].empty?
-      flash.now[:warning] = 'Please enter a valid email address.'
-    elsif (user = User.find_by_email(params[:user][:email])).nil?
-      flash.now[:warning] = "We could not find a user with the email address #{params[:user][:email]}"
-    else
-      begin
-        User.transaction(user) do
-          key = user.generate_security_token
-          url = url_for(:action => 'change_password', :user_id => user.id, :key => key)
-          UserNotify.deliver_forgot_password(user, url)
-          flash[:notice] = "Instructions on resetting your password have been emailed to #{params[:user][:email]}"
-        end  
-        unless user?
-          redirect_to :action => 'login'
-          return
-        end
-        redirect_back_or_default :action => 'home'
-      rescue
-        flash.now[:warning] = "Your password could not be emailed to #{params[:user][:email]}"
-      end
-    end
-  end
-
-  def edit
-    return if generate_filled_in
-    do_edit_user(@user)
-  end
-  
-  protected
-    def do_edit_user(user)
-      begin
-        User.transaction(user) do
-          user.attributes = params[:user].delete_if { |k,v| not LoginEngine.config(:changeable_fields).include?(k) }
-          if user.save
-            flash[:notice] = "User details updated"
-          else
-            flash[:warning] = "Details could not be updated! Please retry."
-          end
-        end
-      rescue
-        flash.now[:warning] = "Error updating user details. Please try again later."
-      end
-    end
-  
-  public
-
-  def delete
-    get_user_to_act_on
-    if do_delete_user(@user)
-      logout
-    else
-      redirect_back_or_default :action => 'home'
-    end    
-  end
-  
-  protected
-    def do_delete_user(user)
-      begin
-        if LoginEngine.config(:delayed_delete)
-          User.transaction(user) do
-            key = user.set_delete_after
-            if LoginEngine.config(:use_email_notification)
-              url = url_for(:action => 'restore_deleted', :user_id => user.id, :key => key)
-              UserNotify.deliver_pending_delete(user, url)
-            end
-          end
-        else
-          destroy(@user)
-        end
-        return true
-      rescue
-        if LoginEngine.config(:use_email_notification)
-          flash.now[:warning] = 'The delete instructions were not sent. Please try again later.'
-        else
-          flash.now[:notice] = 'The account has been scheduled for deletion. It will be removed in #{LoginEngine.config(:delayed_delete_days)} days.'
-        end
-        return false
-      end
-    end
-    
-  public
-
-  def restore_deleted
-    get_user_to_act_on
-    @user.deleted = 0
-    if not @user.save
-      flash.now[:warning] = "The account for #{@user['login']} was not restored. Please try the link again."
-      redirect_to :action => 'login'
-    else
-      redirect_to :action => 'home'
-    end
-  end
-
-  protected
-
-  def destroy(user)
-    UserNotify.deliver_delete(user) if LoginEngine.config(:use_email_notification)
-    flash[:notice] = "The account for #{user['login']} was successfully deleted."
-    user.destroy()
-  end
-
-  def protect?(action)
-    if ['login', 'signup', 'forgot_password'].include?(action)
-      return false
-    else
-      return true
-    end
-  end
-
-  # Generate a template user for certain actions on get
-  def generate_blank
-    case request.method
-    when :get
-      @user = User.new
-      render
-      return true
-    end
-    return false
-  end
-
-  # Generate a template user for certain actions on get
-  def generate_filled_in
-    get_user_to_act_on
-    case request.method
-    when :get
-      render
-      return true
-    end
-    return false
-  end
-  
-  # returns the user object this method should act upon; only really
-  # exists for other engines operating on top of this one to redefine...
-  def get_user_to_act_on
-    @user = session[:user]
-  end
-end