openskip-repim 0.1.8

data/ChangeLog

@@ -0,0 +1,21 @@
+== 0.1.7 / 2009-05-22
+* fix up old style rspec test (generator's)
+* add how to use. (patch from yhara)
+
+== 0.1.6 / 2009-04-02
+* change default after_create_url to root_url
+
+== 0.1.5 / 2009-03-26
+* add gem dependency information as plugin.
+* remove unuse test from generator.
+
+== 0.1.4 / 2009-03-25
+* add dependency to open_id_authentication gems on http://github.com/moro/open_id_authentication
+
+== 0.1.3 / 2009-03-24
+* fix typo
+
+== 0.0.1 / 2009-03-04
+
+* initial release
+

data/README.rdoc

@@ -0,0 +1,43 @@
+
+= repim
+
+== Description
+
+repim (RElying Party In Minutes) is a rails plugin to
+create websites using OpenID authentication easily.
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install moro-repim
+
+
+== Features/Problems
+
+
+== Synopsis
+
+Generate template files
+
+  $ ruby script/generate relying_party Sessions name:string display_name:string
+
+Edit config/environment.rb to load repim gem
+
+  config.gem 'moro-repim', :lib => 'repim', :source => 'http://gems.github.com/'
+
+Start server
+  
+  $ ruby script/server
+
+You will see the login form in http://localhost:3000/signin .
+
+== Copyright
+
+Author::    MOROHASHI Kyosuke <moronatural@gmail.com>
+Copyright:: Copyright (c) 2009 MOROHASHI Kyosuke
+License::   MIT

data/Rakefile

@@ -0,0 +1,184 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+require 'spec/rake/spectask'
+require 'lib/repim'
+include FileUtils
+
+use_rubyforge = false
+NAME              = ENV["GEMNAME"] || "repim"
+AUTHOR            = "MOROHASHI Kyosuke"
+EMAIL             = "moronatural@gmail.com"
+DESCRIPTION       = "Relying Party in minutes."
+
+if use_rubyforge
+  require 'rake/contrib/rubyforgepublisher'
+  require 'rake/contrib/sshpublisher'
+  RUBYFORGE_PROJECT = "repim"
+  HOMEPAGE          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+else
+  HOMEPAGE          = "http://github.com/moro/#{NAME}/"
+end
+BIN_FILES         = %w(  )
+
+VERS              = Repim::Version
+REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = [
+	'--title', "#{NAME} documentation",
+	"--charset", "utf-8",
+	"--opname", "index.html",
+	"--line-numbers",
+	"--main", "README.rdoc",
+	"--inline-source",
+]
+
+task :default => [:spec]
+task :package => [:clean]
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = %w[--colour --format progress --loadby --reverse]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run both plugin's and sample_app's"
+  task :all => %w[spec spec:sample_app]
+
+  desc "Run Sample app's tests"
+  task :sample_app do
+    begin
+      Dir.chdir("integration/sample-app") do
+        unless File.directory?("./vendor/plugins/open_id_authentication")
+          system(*%w[script/plugin install git://github.com/rails/open_id_authentication.git])
+        end
+        system("script/generate relying_party sessions")
+        system($0, "db:migrate")
+        system($0, "spec")
+      end
+    ensure
+      Rake::Task["spec:sample_app:clean"].invoke
+    end
+  end
+
+  namespace :sample_app do
+    desc "Clean Sample app's generated datas"
+    task :clean do
+      Dir.chdir("integration/sample-app") do
+        system("script/destroy relying_party sessions")
+        FileUtils.rm_f(["db/development.sqlite3", "db/test.sqlite3"])
+      end
+    end
+  end
+end
+
+spec = Gem::Specification.new do |s|
+	s.name              = NAME
+	s.version           = VERS
+	s.platform          = Gem::Platform::RUBY
+	s.has_rdoc          = false
+	s.extra_rdoc_files  = ["README.rdoc", "ChangeLog"]
+	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+	s.summary           = DESCRIPTION
+	s.description       = DESCRIPTION
+	s.author            = AUTHOR
+	s.email             = EMAIL
+	s.homepage          = HOMEPAGE
+	s.executables       = BIN_FILES
+	s.rubyforge_project = RUBYFORGE_PROJECT if use_rubyforge
+	s.bindir            = "bin"
+	s.require_path      = "lib"
+	s.test_files        = Dir["test/*_test.rb"]
+
+	s.add_dependency('moro-open_id_authentication')
+	#s.required_ruby_version = '>= 1.8.2'
+
+	s.files = %w(README.rdoc ChangeLog Rakefile) +
+		Dir.glob("{bin,doc,test,lib,templates,generators,extras,website,script}/**/*") + 
+		Dir.glob("ext/**/*.{h,c,rb}") +
+		Dir.glob("examples/**/*.rb") +
+		Dir.glob("tools/*.rb") +
+		Dir.glob("rails/*.rb")
+
+	s.extensions = FileList["ext/**/extconf.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+	p.gem_spec = spec
+end
+
+task :install do
+	name = "#{NAME}-#{VERS}.gem"
+	sh %{rake package}
+	sh %{gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+	sh %{gem uninstall #{NAME}}
+end
+
+desc 'Show information about the gem.'
+task :debug_gem do
+	puts spec.to_ruby
+end
+
+desc 'Update gem spec'
+task :gemspec do
+  open("#{NAME}.gemspec", 'w').write spec.to_ruby
+end
+
+
+Rake::RDocTask.new do |rdoc|
+	rdoc.rdoc_dir = 'html'
+	rdoc.options += RDOC_OPTS
+	rdoc.template = "resh"
+	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+	if ENV['DOC_FILES']
+		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+	else
+		rdoc.rdoc_files.include('README', 'ChangeLog')
+		rdoc.rdoc_files.include('lib/**/*.rb')
+		rdoc.rdoc_files.include('ext/**/*.c')
+	end
+end
+
+if use_rubyforge
+  desc "Publish to RubyForge"
+  task :rubyforge => [:rdoc, :package] do
+    require 'rubyforge'
+    Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'moro').upload
+  end
+
+  desc 'Package and upload the release to rubyforge.'
+  task :release => [:clean, :package] do |t|
+    v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+    abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
+    pkg = "pkg/#{NAME}-#{VERS}"
+
+    require 'rubyforge'
+    rf = RubyForge.new.configure
+    puts "Logging in"
+    rf.login
+
+    c = rf.userconfig
+  #	c["release_notes"] = description if description
+  #	c["release_changes"] = changes if changes
+    c["preformatted"] = true
+
+    files = [
+      "#{pkg}.tgz",
+      "#{pkg}.gem"
+    ].compact
+
+    puts "Releasing #{NAME} v. #{VERS}"
+    rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
+  end
+end
+

data/generators/relying_party/relying_party_generator.rb

@@ -0,0 +1,115 @@
+class RelyingPartyGenerator < Rails::Generator::NamedBase
+  def add_options!(opt)
+    opt.on("--skip-plugins-spec",
+           "Do'nt copy application_controller_spec.rb and #{plural_name}_controller_spec.rb, default is #{!using_rspec?}"){|v| options[:skip_sessions_spec] = true }
+    opt.on("--user-class=klass",
+           "Specify User class name defailt is [User]"){|v| options[:user_klass] = "User" }
+    opt.on("--user-management=generation_type",
+           "'model' for generate (rspec_)model, 'singnup' for controller using Repim::Signup. default is 'signup'"){|v| options[:user_model_only] = (v == "model") }
+    opt.on("--openid-migration=migration_name",
+           "Specify openid migration name, default is 'open_id_authentication_tables'. If value is 'none' generate nothing.") do |v|
+      options[:openid_migration] = v
+    end
+  end
+
+  def manifest
+    controller_file_name  = plural_name + "_controller"
+    controller_class_name = controller_file_name.camelize
+
+    record do |m|
+      m.file "sessions_controller.rb", "app/controllers/#{controller_file_name}.rb"
+      assign_session_routing(singular_name, m)
+
+      m.directory "app/views/layouts"
+      m.file "views/layouts/sessions.html.erb", "app/views/layouts/#{plural_name}.html.erb"
+
+      m.directory "app/views/#{plural_name}"
+      m.file "views/sessions/new.html.erb", "app/views/#{plural_name}/new.html.erb"
+
+      %w[public/images/openid-login.gif public/stylesheets/repim.css].each do |asset|
+        m.directory File.dirname(asset)
+        m.file asset, asset
+      end
+
+      unless options[:skip_sessions_spec]
+        m.directory "spec/controllers"
+        m.file "spec/application_controller_spec.rb", "spec/controllers/application_controller_spec.rb"
+        m.file "spec/sessions_controller_spec.rb", "spec/controllers/#{controller_file_name}_spec.rb"
+
+        m.directory "spec/routing"
+        m.file "spec/sessions_routing_spec.rb", "spec/routing/#{plural_name}_routing_spec.rb"
+      end
+
+      generate_user_management(m, !options[:skip_sessions_spec]) unless options[:user_model_only]
+      m.dependency(care_rspec("model"), [user_klass_name, "identity_url:string", @args].flatten.compact)
+
+      # FIXME very veriy dirty
+      # "sleep 3" is for changing timestamp of 'create_user' or 'open_id_authentication_tables'
+      if options[:command] == :create
+        m.gsub_file(app_controller, /(^\s*helper\s.*?$)/mi) do |ms|
+          sleep 3
+          "#{ms}\n  include Repim::Application"
+        end
+      else
+        m.gsub_file(app_controller, /(^\s*include Repim::Application\s*$)/mi){|m| "" }
+      end
+
+      unless options[:openid_migration] == "none"
+        name = options[:openid_migration] || "open_id_authentication_tables"
+        m.dependency("open_id_authentication_tables", [name])
+      end
+    end
+  end
+
+  private
+  def app_controller
+    %w[application_controller application].
+      map{|f| "app/controllers/#{f}.rb" }.
+      detect{|c| File.exists?(File.expand_path(c, RAILS_ROOT)) }
+  end
+
+  def care_rspec(base); using_rspec? ? "rspec_#{base}" : base end
+
+  def using_rspec?; File.directory?( File.expand_path("spec", RAILS_ROOT) ) end
+
+  def assign_session_routing(name, manifest)
+    sentinel = 'ActionController::Routing::Routes.draw do |map|'
+
+    logger.route "map.resource #{name}"
+    route = <<EOS
+
+  map.signin  '/signin',  :controller => 'sessions', :action => 'new'
+  map.signout '/signout', :controller => 'sessions', :action => 'destroy'
+  map.resource :session
+EOS
+
+    unless options[:pretend]
+      if options[:command] == :create
+        manifest.gsub_file 'config/routes.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+          "#{match}#{route}"
+        end
+      else
+        manifest.gsub_file 'config/routes.rb', route, ''
+      end
+    end
+  end
+
+  def user_klass_name
+    options[:user_klass] || "User"
+  end
+  def generate_user_management(m, with_spec = true)
+    users = user_klass_name.pluralize.underscore
+    user_controller_name =  users + "_controller"
+
+    m.route_resources users.to_sym
+    m.file("users_controller.rb", "app/controllers/#{user_controller_name}.rb")
+
+    m.directory "app/views/#{users}"
+    m.template "views/users/new.html.erb", "app/views/#{users}/new.html.erb", :assigns => {:user => user_klass_name.underscore, :users => users}
+
+    if with_spec
+      m.file "spec/users_controller_spec.rb", "spec/controllers/#{user_controller_name}_spec.rb"
+      m.file "spec/users_routing_spec.rb", "spec/routing/#{users}_routing_spec.rb"
+    end
+  end
+end

data/generators/relying_party/templates/public/stylesheets/repim.css

@@ -0,0 +1,9 @@
+div#login-or-signup input[name=openid_url] {
+  font-size: 16px;
+  width: 20em;
+  padding: 2px 2px 2px 20px;
+  background-image: url("../images/openid-login.gif");
+  background-repeat: no-repeat;
+  background-attachment: scroll;
+  background-position: 0 50%;
+}

data/generators/relying_party/templates/sessions_controller.rb

@@ -0,0 +1,4 @@
+class SessionsController < ApplicationController
+  include OpenIdAuthentication
+  include Repim::RelyingParty
+end

data/generators/relying_party/templates/spec/application_controller_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ApplicationController do
+  before :all do
+    ApplicationController.user_klass = mock("User-Klass")
+  end
+  describe "#logged in" do
+    before do
+      session[:user_id] = 12345
+      ApplicationController.user_klass.should_receive(:find_by_id).with(12345).and_return(@user = mock("user"))
+    end
+
+    it{ controller.should be_signed_in }
+    it{ controller.current_user.should == @user }
+  end
+end
+

data/generators/relying_party/templates/spec/sessions_controller_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SessionsController do
+  before :all do
+    SessionsController.user_klass = mock("User-Klass")
+  end
+
+  #Delete this example and add some real ones
+  it "should use SessionsController" do
+    controller.should be_an_instance_of(SessionsController)
+  end
+
+  it "get new should be success" do
+    get :new
+    response.should be_success
+  end
+
+  def mock_out_authenticattion(controller, url, is_success)
+    result = mock("result")
+    result.should_receive(:successful?).and_return is_success
+
+    controller.
+      should_receive(:authenticate_with_open_id).
+      with(url, an_instance_of(Hash)).
+      and_return{|url, ax, block| block.call(result, url, ax) }
+  end
+
+  describe "authentication success" do
+    before do
+      url = "---openid-url---"
+
+      @user = mock("user", :id => 12345)
+      SessionsController.user_klass.should_receive(:find_by_identity_url).with(url).and_return(@user)
+
+      controller.should_receive(:root_path).and_return("/")
+      mock_out_authenticattion(controller, url, true)
+
+      post :create, :openid_url =>url
+    end
+
+    it{ response.should redirect_to("/") }
+    it{ session[:user_id].should == 12345 }
+    it{ controller.current_user.should == @user }
+    it{ controller.should be_signed_in }
+  end
+
+  describe "authentication success but user not found then render users/new" do
+    before do
+      url = "---openid-url---"
+      SessionsController.user_klass.should_receive(:find_by_identity_url).with(url).and_return(nil)
+      SessionsController.user_klass.should_receive(:new).with({}).and_return(@user = mock("user"))
+
+      mock_out_authenticattion(controller, url, true)
+
+      post :create, :openid_url =>url
+    end
+
+    it{ response.should render_template("users/new") }
+    it{ controller.current_user.should be_nil }
+    it{ controller.should_not be_signed_in }
+    it{ assigns[:user].should == @user }
+  end
+
+  describe "authentication failed" do
+    before do
+      url = "---openid-url---"
+
+      mock_out_authenticattion(controller, url, false)
+
+      post :create, :openid_url =>url
+    end
+
+    it{ response.should render_template("sessions/new") }
+    it{ assigns[:user].should be_nil }
+    it{ controller.current_user.should be_nil }
+    it{ session[:user_id].should be_nil }
+    it{ flash[:error].should_not be_blank }
+  end
+end

data/generators/relying_party/templates/spec/sessions_routing_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SessionsController do
+  describe "route generation" do
+    it "should map #new -> /signin" do
+      route_for(:controller => "sessions", :action => "new").should == "/signin"
+    end
+
+    it "should map #destroy -> /signout" do
+      route_for(:controller => "sessions", :action => "destroy").should == {:path => "/signout", :method => "DELETE"}
+    end
+
+    it "should map #create" do
+      route_for(:controller => "sessions", :action => "create").should == {:path => "/session", :method => "POST"}
+    end
+  end
+
+  describe "route recognition" do
+    it "should generate params for #new" do
+      params_from(:get, "/signin").should == {:controller => "sessions", :action => "new"}
+    end
+
+    it "should generate params for #new" do
+      params_from(:get, "/session/new").should == {:controller => "sessions", :action => "new"}
+    end
+
+    it "should generate params for #create" do
+      params_from(:post, "/session").should == {:controller => "sessions", :action => "create"}
+    end
+
+    it "should generate params for #show (JS)" do
+      params_from(:get, "/session.js").should == {:controller => "sessions", :action => "show", :format => "js"}
+    end
+
+    it "should generate params for #destroy" do
+      params_from(:get, "/signout").should == {:controller => "sessions", :action => "destroy"}
+    end
+
+    it "should generate params for #destroy" do
+      params_from(:delete, "/session").should == {:controller => "sessions", :action => "destroy"}
+    end
+  end
+end

data/generators/relying_party/templates/spec/users_controller_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe UsersController do
+  def mock_user(stubs={})
+    @mock_user ||= mock_model(User, stubs)
+  end
+
+  describe "responding to GET index" do
+    before do
+      controller.stub!(:authenticate).and_return true
+    end
+    it "should expose all users as @users" do
+      User.should_receive(:find).with(:all).and_return([mock_user])
+      get :index
+      assigns[:users].should == [mock_user]
+    end
+
+    describe "with mime type of xml" do
+      it "should render all users as xml" do
+        request.env["HTTP_ACCEPT"] = "application/xml"
+        User.should_receive(:find).with(:all).and_return(users = mock("Array of Users"))
+        users.should_receive(:to_xml).and_return("generated XML")
+        get :index
+        response.body.should == "generated XML"
+      end
+    end
+  end
+
+  describe "responding to GET show" do
+    before do
+      controller.stub!(:authenticate).and_return true
+    end
+
+    it "should expose the requested user as @user" do
+      User.should_receive(:find).with("37").and_return(mock_user)
+      get :show, :id => "37"
+      assigns[:user].should equal(mock_user)
+    end
+
+    describe "with mime type of xml" do
+      it "should render the requested user as xml" do
+        request.env["HTTP_ACCEPT"] = "application/xml"
+        User.should_receive(:find).with("37").and_return(mock_user)
+        mock_user.should_receive(:to_xml).and_return("generated XML")
+        get :show, :id => "37"
+        response.body.should == "generated XML"
+      end
+    end
+  end
+
+  describe "responding to POST create" do
+    describe "with valid params" do
+      before do
+        User.should_receive(:new).with({'these' => 'params'}).and_return(mock_user(:save => true))
+
+        @identity_url = session[:identity_url] = "http://moro.openid.example.com/"
+        mock_user.should_receive(:identity_url=).with(@identity_url)
+
+        post :create, :user => {:these => 'params'}
+      end
+
+      it "should expose a newly created user as @user" do
+        assigns(:user).should equal(mock_user)
+      end
+
+      it "session[:identity_url] should be removed" do
+        session[:identity_url].should be_blank
+      end
+
+      it "should redirect to the created user" do
+        response.should redirect_to(user_url(mock_user))
+      end
+    end
+
+    describe "with invalid params" do
+      before do
+        User.stub!(:new).with({'these' => 'params'}).and_return(mock_user(:save => false))
+
+        @identity_url = session[:identity_url] = "http://moro.openid.example.com/"
+        mock_user.should_receive(:identity_url=).with(@identity_url)
+
+        post :create, :user => {:these => 'params'}
+      end
+
+      it "should expose a newly created but unsaved user as @user" do
+        assigns(:user).should equal(mock_user)
+      end
+
+      it "should re-render the 'new' template" do
+        response.should render_template('new')
+      end
+
+      it "session[:identity_url] should == original" do
+        session[:identity_url].should == @identity_url
+      end
+    end
+  end
+end

data/generators/relying_party/templates/spec/users_routing_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe UsersController do
+  describe "route generation" do
+    it "should map #index" do
+      route_for(:controller => "users", :action => "index").should == {:path => "/users", :method => "GET"}
+    end
+  
+    it "should map #new" do
+      route_for(:controller => "users", :action => "new").should == {:path => "/users/new", :method => "GET"}
+    end
+  
+    it "should map #show" do
+      route_for(:controller => "users", :action => "show", :id => "1").should == {:path => "/users/1", :method => "GET"}
+    end
+  
+    it "should map #edit" do
+      route_for(:controller => "users", :action => "edit", :id => "1").should == {:path => "/users/1/edit", :method => "GET"}
+    end
+  
+    it "should map #update" do
+      route_for(:controller => "users", :action => "update", :id => "1").should == {:path => "/users/1", :method => "PUT"}
+    end
+  
+    it "should map #destroy" do
+      route_for(:controller => "users", :action => "destroy", :id => "1").should == {:path => "/users/1", :method => "DELETE"}
+    end
+  end
+
+  describe "route recognition" do
+    it "should generate params for #index" do
+      params_from(:get, "/users").should == {:controller => "users", :action => "index"}
+    end
+  
+    it "should generate params for #new" do
+      params_from(:get, "/users/new").should == {:controller => "users", :action => "new"}
+    end
+  
+    it "should generate params for #create" do
+      params_from(:post, "/users").should == {:controller => "users", :action => "create"}
+    end
+  
+    it "should generate params for #show" do
+      params_from(:get, "/users/1").should == {:controller => "users", :action => "show", :id => "1"}
+    end
+  
+    it "should generate params for #edit" do
+      params_from(:get, "/users/1/edit").should == {:controller => "users", :action => "edit", :id => "1"}
+    end
+  
+    it "should generate params for #update" do
+      params_from(:put, "/users/1").should == {:controller => "users", :action => "update", :id => "1"}
+    end
+  
+    it "should generate params for #destroy" do
+      params_from(:delete, "/users/1").should == {:controller => "users", :action => "destroy", :id => "1"}
+    end
+  end
+end

data/generators/relying_party/templates/users_controller.rb

@@ -0,0 +1,27 @@
+class UsersController < ApplicationController
+  include Repim::Signup
+
+  def index
+    @users = User.find(:all)
+
+    respond_to do |format|
+      format.html
+      format.xml  { render :xml => @users }
+    end
+  end
+
+  def show
+    @user = User.find(params[:id])
+
+    respond_to do |format|
+      format.html
+      format.xml  { render :xml => @user }
+    end
+  end
+
+  # uncomment and edit this to change redirected url after signup.
+  # private
+  # def after_create_url
+  #   user_url(current_user)
+  # end
+end

data/generators/relying_party/templates/views/layouts/sessions.html.erb

@@ -0,0 +1,18 @@
+<html>
+  <head>
+    <%= stylesheet_link_tag "repim" %>
+    <%= javascript_include_tag :defaults %>
+  </head>
+  <body>
+    <div id="header">
+      <% if signed_in? -%>
+        <span class="current-user"> Logged in as <%= current_user.identity_url %> </span>
+      <% else -%>
+        <span class="sign-in"><%= link_to "Sign in", new_session_path %></span>
+      <% end -%>
+    </div>
+    <div id="content">
+      <%= yield %>
+    </div>
+  </body>
+</html>

data/generators/relying_party/templates/views/sessions/new.html.erb

@@ -0,0 +1,16 @@
+<% content_for :stylesheet do -%>
+  <%= stylesheet_link_tag "repim" %>
+<% end %>
+<h1>Welcome</h1>
+
+<div id="login-or-signup">
+  <p> Please login or signup using OpenID.</p>
+
+  <% form_tag session_path do -%>
+  <label for="openid_url">OpenID URL</label>
+  <%= text_field_tag "openid_url", params[:openid_url] %>
+
+  <%= submit_tag "Login or Signup" %>
+  <% end %>
+</div>
+

data/generators/relying_party/templates/views/users/new.html.erb

@@ -0,0 +1,23 @@
+<h1>Sign up</h1>
+
+<%% form_for(@<%= user %>) do |f| %>
+  <%%= f.error_messages %>
+
+  <table>
+<% for attribute in attributes -%>
+    <tr>
+      <th> <%%= f.label :<%= attribute.name %> %></th>
+      <td><%%= f.<%= attribute.field_type %> :<%= attribute.name %> %></td>
+    </tr>
+<% end -%>
+    <tr>
+      <th>OpenID URL</th>
+      <td><%%=h session[:identity_url] %></td>
+    </tr>
+  </table>
+  <p>
+    <%%= f.submit 'Create' %>
+  </p>
+<%% end %>
+
+<%%= link_to 'Back', <%= users %>_path %>

data/lib/repim/application.rb

@@ -0,0 +1,70 @@
+require "repim/random"
+
+module Repim
+  module Application
+    def self.included(base)
+      base.cattr_accessor :user_klass
+      base.cattr_accessor :login_template
+      base.cattr_accessor :with_single_access
+      base.user_klass = (User rescue nil) # assign nil when LoadError and/or ConstMissing
+      base.login_template = "sessions/new"
+      base.with_single_access = (base.user_klass.column_names.include?('single_access_token') rescue false)
+
+      base.before_filter :authenticate
+      [:current_user, :signed_in?, :logged_in?].each do |method|
+        base.helper_method method
+        base.hide_action method
+      end
+    end
+
+    def signed_in?; !!current_user ; end
+    alias logged_in? signed_in?
+
+    def current_user
+      return nil if @__current_user__ == false
+      return @__current_user__ if @__current_user__
+      @__current_user__ ||= (user_from_session || false)
+      current_user # call again
+    end
+
+    private
+    def authenticate
+      signed_in? || access_denied("Login required.")
+    end
+    alias login_required authenticate
+
+    def access_denied(message = nil)
+      store_location
+      flash[:error] = message if message
+      render :template => login_template, :status => :unauthorized
+    end
+
+    def store_location
+      session[:return_to] = request.request_uri if request.get?
+    end
+
+    def current_user=(user)
+      @__current_user__ = user
+      if self.class.with_single_access
+        # TODO Rails2.3以降で利用するか、もう少しセキュアなランダムを作成できるようにしたほうがよい
+        user.single_access_token = Repim::Random.friendly_token
+        session[:single_access_token] = user.single_access_token
+        user.save(false)
+      else
+        session[:user_id] = user.id
+      end
+    end
+
+    def user_from_session
+      if self.class.with_single_access
+        session[:single_access_token] && user_klass.find_by_single_access_token(session[:single_access_token])
+      else
+        session[:user_id] && user_klass.find_by_id(session[:user_id])
+      end
+    end
+
+    def redirect_back_or(default)
+      redirect_to(session[:return_to] || default)
+    end
+  end
+end

data/lib/repim/ax_attributes_adapter.rb

@@ -0,0 +1,32 @@
+require 'active_support'
+
+module Repim
+  class AxAttributeAdapter
+    attr_reader :rule, :necessity
+
+    # TODO refactor
+    def initialize(prefixes, propaties)
+      @rule = {}
+      @necessity = :optional
+      propaties.each do |model_attr, property|
+        @rule[model_attr] = prefixes.map{|px| px + property }
+      end
+    end
+
+    def keys
+      rule.values.flatten
+    end
+
+    def required!
+      @necessity = :required
+    end
+
+    def adapt(fetched)
+      returning({}) do |res|
+        rule.each do |k, vs|
+          fetched.each{|fk, (fv,_)| res[k] = fv if !fv.blank? && vs.include?(fk) }
+        end
+      end
+    end
+  end
+end

data/lib/repim/random.rb

@@ -0,0 +1,33 @@
+module Repim
+  # Handles generating random strings. If SecureRandom is installed it will default to this and use it instead. SecureRandom comes with ActiveSupport.
+  # So if you are using this in a rails app you should have this library.
+  module Random
+    extend self
+
+    SecureRandom = (defined?(::SecureRandom) && ::SecureRandom) || (defined?(::ActiveSupport::SecureRandom) && ::ActiveSupport::SecureRandom)
+
+    if SecureRandom
+      def hex_token
+        SecureRandom.hex(64)
+      end
+
+      def friendly_token
+        # use base64url as defined by RFC4648
+        SecureRandom.base64(15).tr('+/=', '-_ ').strip.delete("\n")
+      end
+    else
+      def hex_token
+        Authlogic::CryptoProviders::Sha512.encrypt(Time.now.to_s + (1..10).collect{ rand.to_s }.join)
+      end
+
+      FRIENDLY_CHARS = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+
+      def friendly_token
+        newpass = ""
+        1.upto(20) { |i| newpass << FRIENDLY_CHARS[rand(FRIENDLY_CHARS.size-1)] }
+        newpass
+      end
+    end
+
+  end
+end

data/lib/repim/relying_party.rb

@@ -0,0 +1,101 @@
+require 'repim/ax_attributes_adapter'
+
+module Repim
+  module RelyingParty
+    def self.included(base)
+      base.cattr_accessor :attribute_adapter
+      base.cattr_accessor :signup_template
+
+      base.skip_before_filter :authenticate
+      base.signup_template = "users/new"
+
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def use_attribute_exchange(prefixes, propaties)
+        self.attribute_adapter = AxAttributeAdapter.new(prefixes, propaties)
+      end
+    end
+
+    # render new.rhtml
+    def new
+    end
+
+    def create
+      options = {}
+      options[attribute_adapter.necessity] = attribute_adapter.keys if attribute_adapter
+
+      begin
+        authenticate_with_open_id(params[:openid_url], options) do |result, identity_url, personal_data|
+          if result.successful?
+            authenticate_success(identity_url, personal_data)
+          else
+            authenticate_failure(params.merge(:openid_url=>identity_url))
+          end
+        end
+      rescue OpenID::OpenIDError => why
+        logger.debug{ [why.message, why.backtrace].flatten.join("\n\t") }
+        authenticate_failure(params)
+      end
+    end
+
+    def destroy
+      if self.class.with_single_access
+        current_user.single_access_token = nil
+        current_user.save(false)
+        session[:single_access_token] = nil
+      else
+        session[:user_id] = nil
+      end
+      reset_session
+      flash[:notice] = "You have been logged out."
+
+      redirect_back_or(after_logout_path)
+    end
+
+    private
+    def authenticate_success(identity_url, personal_data = {})
+      if user = user_klass.find_by_identity_url(identity_url)
+        login_successfully(user, personal_data)
+        redirect_back_or(after_login_path)
+      else
+        signup(identity_url, personal_data)
+        render(:template => signup_template)
+      end
+    end
+
+    def login_successfully(user, personal_data)
+      reset_session
+      self.current_user = user
+      flash[:notice] ||= "Logged in successfully"
+    end
+
+    def signup(identity_url, ax = {})
+      session[:identity_url] = identity_url
+      @user = user_klass.new( attribute_adapter ? attribute_adapter.adapt(ax) : {} )
+    end
+
+    # log login faulure. and re-render sessions/new
+    def authenticate_failure(assigns = params)
+      flash[:error] = "Couldn't log you in as '#{assigns[:openid_url] || assigns["openid.claimed_id"]}'"
+      logger.warn "Failed login for '#{assigns[:openid_url]}' from #{request.remote_ip} at #{Time.now.utc}"
+
+      @openid_url  = assigns[:openid_url]
+
+      render :action => 'new'
+    end
+
+    def after_login_path; root_path ; end
+    def after_logout_path; login_path ; end
+
+    def method_missing(m, *args, &b)
+      return [request.protocol, request.host_with_port, "/"].join if m.to_sym == :root_url
+      super
+    end
+
+    def verify_authenticity_token
+       super unless ('create' == params[:action] && '1' == params[:open_id_complete])
+    end
+  end
+end

data/lib/repim/signup.rb

@@ -0,0 +1,28 @@
+module Repim
+  module Signup
+    def self.included(base)
+      base.before_filter :authenticate, :except => [:create]
+    end
+
+    def create
+      @user = User.new(params[:user])
+      @user.identity_url = session[:identity_url]
+
+      respond_to do |format|
+        if @user.save
+          flash[:notice] = 'User was successfully created.'
+          reset_session
+          self.current_user = @user
+          format.html { redirect_to(after_create_url(@user)) }
+        else
+          format.html { render :action => "new" }
+        end
+      end
+    end
+
+    private
+    def after_create_url(created)
+      respond_to?(:root_url) ? root_url : user_url(created)
+    end
+  end
+end

data/lib/repim.rb

@@ -0,0 +1,3 @@
+module Repim
+  Version = '0.1.8'
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+# add hook to activate in rails app.
+#
+# example.
+# ActiveRecrod::Base.send(:include, Repim)
+
+require 'repim/application'
+config.gem 'moro-open_id_authentication', :lib => 'open_id_authentication', :source => 'http://gems.github.com/'
+

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: openskip-repim
+version: !ruby/object:Gem::Version 
+  version: 0.1.8
+platform: ruby
+authors: 
+- MOROHASHI Kyosuke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: moro-open_id_authentication
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Relying Party in minutes.
+email: moronatural@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- ChangeLog
+files: 
+- README.rdoc
+- ChangeLog
+- Rakefile
+- lib/repim
+- lib/repim/application.rb
+- lib/repim/ax_attributes_adapter.rb
+- lib/repim/random.rb
+- lib/repim/relying_party.rb
+- lib/repim/signup.rb
+- lib/repim.rb
+- generators/relying_party
+- generators/relying_party/relying_party_generator.rb
+- generators/relying_party/templates
+- generators/relying_party/templates/public
+- generators/relying_party/templates/public/images
+- generators/relying_party/templates/public/images/openid-login.gif
+- generators/relying_party/templates/public/stylesheets
+- generators/relying_party/templates/public/stylesheets/repim.css
+- generators/relying_party/templates/sessions_controller.rb
+- generators/relying_party/templates/spec
+- generators/relying_party/templates/spec/application_controller_spec.rb
+- generators/relying_party/templates/spec/sessions_controller_spec.rb
+- generators/relying_party/templates/spec/sessions_routing_spec.rb
+- generators/relying_party/templates/spec/users_controller_spec.rb
+- generators/relying_party/templates/spec/users_routing_spec.rb
+- generators/relying_party/templates/users_controller.rb
+- generators/relying_party/templates/views
+- generators/relying_party/templates/views/layouts
+- generators/relying_party/templates/views/layouts/sessions.html.erb
+- generators/relying_party/templates/views/sessions
+- generators/relying_party/templates/views/sessions/new.html.erb
+- generators/relying_party/templates/views/users
+- generators/relying_party/templates/views/users/new.html.erb
+- rails/init.rb
+has_rdoc: false
+homepage: http://github.com/moro/repim/
+post_install_message: 
+rdoc_options: 
+- --title
+- repim documentation
+- --charset
+- utf-8
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README.rdoc
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+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.2.0
+signing_key: 
+specification_version: 3
+summary: Relying Party in minutes.
+test_files: []
+