OpenIDとRails：Authentication 2.0

# script/generate controller login

require 'ostruct'

class LoginController < ApplicationController

  def index
    redirect_to :controller => "todos" if session[:user_id]
  end

  def login
    if using_open_id?
      authenticate
    else
      flash[:error] = "You must provide an OpenID URL"
      redirect_to :action => "index"
    end
  end

  def logout
    session[:user_id] = nil
    redirect_to :action => "index"
  end

  protected
    def authenticate(identity_url = "")
      authenticate_with_open_id(
      params[:openid_url], :required => [:nickname, :email]) do
        |result, identity_url, registration|

        if result.successful?
          @user = OpenStruct.new
          @user.identity_url = identity_url
          @user.nickname = registration["nickname"]
          @user.email = registration["email"]
          session[:user_id] = @user

          jumpto = session[:jumpto] || { :controller => "todos" }
          session[:jumpto] = nil
          redirect_to(jumpto)
        else
          flash[:error] = result.message
          redirect_to :action => "index"
        end
      end
    end

    def root_url
      openid_url
    end
end

<% if flash[:error] -%>
  <%= flash[:error] %>
<% end -%>
<% form_tag :controller => "login" , :action => "login" do |f| -%>
  <label for="openid_url" >
    OpenId URL:
  </label>
  <%= text_field_tag :openid_url -%>
  <%= submit_tag "Login" -%>
<% end -%>

map.openid "login",
  :controller => "login" ,
  :requirements => { :method => :get }

def root_url
  openid_url
end

def new
  @todo = Todo.new
  @todo.person = session[:user_id].nickname
  @todo.email = session[:user_id].email

  respond_to do |format|
    format.html # new.html.erb
    format.xml  { render :xml => @todo }
  end
end

require "openid"
require 'user'

class OpenID::Consumer
  attr_accessor :referer
end

class LoginController < ApplicationController

  def login
    if session[:user]
      @login = session[:user]
      render :action => 'status' , :layout => false
      return
    end

    if params[:login]
      @login = OpenID::OpenidUser.from_params(params[:login])

      if @login.validate

        store_dir = OPENID_STORE_DIR
        store = OpenID::FilesystemStore.new(store_dir)

        consumer = OpenID::Consumer.new(session, store)
        consumer.referer = @request.env['HTTP_REFERER']
        req = consumer.begin(@login.openid)
        case req.status
        when OpenID::FAILURE
          @login.errors.add(:openid,"Unable to find OpenID server")
        when OpenID::SUCCESS
          # simple registration procedure to extract
          # the email, nickname and fullname (if available)
          req.add_extension_arg('sreg','required','email,nickname')
          req.add_extension_arg('sreg','optional','fullname')

          @redirect_url = req.redirect_url(BASE_URL,
            url_for( :action => 'complete'))
          # save the consumer for later use
          session[:consumer] = consumer
          session[:temp_login] = @login

          redirect_to @redirect_url
        else
          # should never arrive here
          raise "Unreachable code"
        end

      end
    end

    render :action => 'status' , :layout => false
  end

  def complete
    if session[:user]
      @login = session[:user]
      render :action => 'status' , :layout => false
      return
    end

    consumer = session[:consumer]
    session[:consumer] = nil # consume consumer
    if consumer.nil?
      render :action => 'status' , :layout => false
      return
    end

    res = consumer.complete(params)
    if res.status == OpenID::FAILURE
      flash[:login_notice] = "Login has been rejected"
    elsif res.status == OpenID::SUCCESS
      sreg = res.extension_response('sreg')
      if sreg.length > 0
        # finalize login
        @login = session[:user] = session[:temp_login]
        @login.email = sreg['email']
        @login.nickname = sreg['nickname']
        @login.fullname = sreg['fullname']
        session[:temp_login] = nil
      end

    elsif res.status == OpenID::CANCEL
      flash[:login_notice] = "Login has been canceled."
    else
      # unknown response type
      flash[:login_notice] = "OpenID provider has returned" +
        " an unknown response type"
    end

    redirect_to consumer.referer
  end

  def logout
    session[:user] = session[:temp_login] = nil
    render :action => 'status', :layout => false
  end
end