openid_fu_generator 0.0.1

data/tasks/deployment.rake

@@ -0,0 +1,34 @@
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end

data/tasks/environment.rake

@@ -0,0 +1,7 @@
+task :ruby_env do
+  RUBY_APP = if RUBY_PLATFORM =~ /java/
+    "jruby"
+  else
+    "ruby"
+  end unless defined? RUBY_APP
+end

data/tasks/website.rake

@@ -0,0 +1,17 @@
+desc 'Generate website files'
+task :website_generate => :ruby_env do
+  (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
+    sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]

data/templates/activation.html.erb

@@ -0,0 +1,3 @@
+<%%= @<%= file_name %>.login %>, your account has been activated.  You may now start adding your plugins:
+
+  <%%= @url %>

data/templates/authenticated_system.rb

@@ -0,0 +1,155 @@
+module AuthenticatedSystem
+protected
+  # Returns true or false if the user is logged in.
+  # Preloads @current_<%= file_name %> with the user model if they're logged in.
+  def logged_in?
+    current_<%= file_name %> != :false
+  end
+  
+  # Accesses the current <%= file_name %> from the session.
+  def current_<%= file_name %>
+    @current_<%= file_name %> ||= (session[:<%= file_name %>] && <%= class_name %>.find_by_id(session[:<%= file_name %>])) || :false
+  end
+  
+  # Store the given <%= file_name %> in the session.
+  def current_<%= file_name %>=(new_<%= file_name %>)
+    session[:<%= file_name %>] = (new_<%= file_name %>.nil? || new_<%= file_name %>.is_a?(Symbol)) ? nil : new_<%= file_name %>.id
+    @current_<%= file_name %> = new_<%= file_name %>
+  end
+  
+  # Check if the <%= file_name %> is authorized.
+  #
+  # Override this method in your controllers if you want to restrict access
+  # to only a few actions or if you want to check if the <%= file_name %>
+  # has the correct rights.
+  #
+  # Example:
+  #
+  #  # only allow nonbobs
+  #  def authorize?
+  #    current_<%= file_name %>.login != "bob"
+  #  end
+  def authorized?
+    true
+  end
+
+  # Filter method to enforce a login requirement.
+  #
+  # To require logins for all actions, use this in your controllers:
+  #
+  #   before_filter :login_required
+  #
+  # To require logins for specific actions, use this in your controllers:
+  #
+  #   before_filter :login_required, :only => [ :edit, :update ]
+  #
+  # To skip this in a subclassed controller:
+  #
+  #   skip_before_filter :login_required
+  #
+  def login_required
+    username, passwd = get_auth_data
+    self.current_<%= file_name %> ||= <%= class_name %>.authenticate(username, passwd) || :false if username && passwd
+    logged_in? && authorized? ? true : access_denied
+  end
+  
+  # Redirect as appropriate when an access request fails.
+  #
+  # The default action is to redirect to the login screen.
+  #
+  # Override this method in your controllers if you want to have special
+  # behavior in case the <%= file_name %> is not authorized
+  # to access the requested action.  For example, a popup window might
+  # simply close itself.
+  def access_denied
+    respond_to do |accepts|
+      accepts.html do
+        store_location
+        return auto_login if request.xhr?
+        redirect_to :controller => '<%= controller_file_name %>',
+          :action => 'new', :open_id_claimed_id => params[:open_id_claimed_id]
+      end
+      accepts.xml do
+        headers["Status"]           = "Unauthorized"
+        headers["WWW-Authenticate"] = %(Basic realm="Web Password")
+        render :text => "Could't authenticate you", :status => '401 Unauthorized'
+      end
+    end
+    false
+  end  
+
+  def auto_login
+    render :update do |page|
+      page << <<-"EOH"
+      (function(){
+        var input, form = document.createElement('form');
+        form.style.position = 'absolute';
+        form.style.left = form.style.top = '-1000px';
+        document.body.appendChild(form);
+        input = form.appendChild(document.createElement('input'));
+        input.name = 'open_id_claimed_id';
+        input.value = #{params[:open_id_claimed_id].to_json};
+        input = form.appendChild(document.createElement('input'));
+        input.name = 'remember_me';
+        input.value = #{params[:remember_me].to_json};
+        input = form.appendChild(document.createElement('input'));
+        input.name = 'authenticity_token';
+        input.value = $$('input[name="authenticity_token"]')[0].value;
+        form.action = #{begin_<%= controller_file_name %>_path.to_json};
+        form.method = 'POST';
+        form.submit();
+      })();
+      EOH
+    end
+    false
+  end
+  
+  # Store the URI of the current request in the session.
+  #
+  # We can return to this location by calling #redirect_back_or_default.
+  def store_location
+    session[:stored_parameters] = params
+    session[:return_to] = request.request_uri
+    session[:return_to_method] = request.method
+  end
+  
+  # Redirect to the URI stored by the most recent store_location call or
+  # to the passed default.
+  def redirect_back_or_default(default)
+    if session[:return_to]
+      render :action => 'restore_location'
+    else
+      redirect_to(default)
+    end
+    session[:return_to] = nil
+    session[:return_to_method] = nil
+  end
+  
+  # Inclusion hook to make #current_<%= file_name %> and #logged_in?
+  # available as ActionView helper methods.
+  def self.included(base)
+    base.send :helper_method, :current_<%= file_name %>, :logged_in?
+  end
+
+  # When called with before_filter :login_from_cookie will check for an :auth_token
+  # cookie and log the user back in if apropriate
+  def login_from_cookie
+    return unless cookies[:auth_token] && !logged_in?
+    user = <%= class_name %>.find_by_remember_token(cookies[:auth_token])
+    if user && user.remember_token?
+      user.remember_me
+      self.current_<%= file_name %> = user
+      cookies[:auth_token] = { :value => self.current_<%= file_name %>.remember_token , :expires => self.current_<%= file_name %>.remember_token_expires_at }
+      flash[:notice] = "Logged in successfully"
+    end
+  end
+
+private
+  @@http_auth_headers = %w(X-HTTP_AUTHORIZATION HTTP_AUTHORIZATION Authorization)
+  # gets BASIC auth info
+  def get_auth_data
+    auth_key  = @@http_auth_headers.detect { |h| request.env.has_key?(h) }
+    auth_data = request.env[auth_key].to_s.split unless auth_key.blank?
+    return auth_data && auth_data[0] == 'Basic' ? Base64.decode64(auth_data[1]).split(':')[0..1] : [nil, nil] 
+  end
+end

data/templates/authenticated_test_helper.rb

@@ -0,0 +1,94 @@
+module AuthenticatedTestHelper
+  # Sets the current <%= file_name %> in the session from the <%= file_name %> fixtures.
+  def login_as(<%= file_name %>)
+    @request.session[:<%= file_name %>] = <%= file_name %> ? <%= table_name %>(<%= file_name %>).id : nil
+  end
+
+  def content_type(type)
+    @request.env['Content-Type'] = type
+  end
+
+  def accept(accept)
+    @request.env["HTTP_ACCEPT"] = accept
+  end
+
+  def authorize_as(user)
+    if user
+      @request.env["HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64("#{users(user).login}:test")}"
+      accept       'application/xml'
+      content_type 'application/xml'
+    else
+      @request.env["HTTP_AUTHORIZATION"] = nil
+      accept       nil
+      content_type nil
+    end
+  end
+
+  # Assert the block redirects to the login
+  # 
+  #   assert_requires_login(:bob) { |c| c.get :edit, :id => 1 }
+  #
+  def assert_requires_login(login = nil)
+    yield HttpLoginProxy.new(self, login)
+  end
+
+  def assert_http_authentication_required(login = nil)
+    yield XmlLoginProxy.new(self, login)
+  end
+
+  def reset!(*instance_vars)
+    instance_vars = [:controller, :request, :response] unless instance_vars.any?
+    instance_vars.collect! { |v| "@#{v}".to_sym }
+    instance_vars.each do |var|
+      instance_variable_set(var, instance_variable_get(var).class.new)
+    end
+  end
+end
+
+class BaseLoginProxy
+  attr_reader :controller
+  attr_reader :options
+  def initialize(controller, login)
+    @controller = controller
+    @login      = login
+  end
+
+  private
+    def authenticated
+      raise NotImplementedError
+    end
+    
+    def check
+      raise NotImplementedError
+    end
+    
+    def method_missing(method, *args)
+      @controller.reset!
+      authenticate
+      @controller.send(method, *args)
+      check
+    end
+end
+
+class HttpLoginProxy < BaseLoginProxy
+  protected
+    def authenticate
+      @controller.login_as @login if @login
+    end
+    
+    def check
+      @controller.assert_redirected_to :controller => 'sessions', :action => 'new'
+    end
+end
+
+class XmlLoginProxy < BaseLoginProxy
+  protected
+    def authenticate
+      @controller.accept 'application/xml'
+      @controller.authorize_as @login if @login
+    end
+    
+    def check
+      @controller.assert_response 401
+    end
+end

data/templates/controller.rb

@@ -0,0 +1,111 @@
+# This controller handles the login/logout function of the site.  
+class <%= controller_class_name %>Controller < ApplicationController
+  include OpenidFu::ControllerMethods
+  # XXX: Be sure to include AuthenticationSystem in Application Controller instead
+  include AuthenticatedSystem
+
+  # Obtain personal identity from OP. If OP accomodates the OpenID Attributes Exchange(AX) or SREG, 
+  # then use AX or SREG, unfortunately if both OpenID Extensions aren't supported then input ones in RP.
+  #
+  # == Examples:
+  #   # Email and nickname are required, gender and birth date are obtained if these are available.
+  #   open_id_consumer :required => [:email, :nickname], :if_available => [:gender, :birth_date]
+  #
+  open_id_consumer :required => [:email, :nickname]
+
+  # XXX: If you want "remember me" functionality, add this before_filter to Application Controller
+  before_filter :login_from_cookie
+
+  rescue_from OpenID::DiscoveryFailure, :with => :begin_error
+
+  def new
+    @<%= file_name %> = <%= class_name %>.new(params[:<%= file_name %>])
+  end
+
+  def create
+    self.current_<%= file_name %> = <%= class_name %>.authenticate(params[:email], params[:password])
+    if logged_in?
+      if params[:remember_me] == "1"
+        self.current_<%= file_name %>.remember_me
+        cookies[:auth_token] = { :value => self.current_<%= file_name %>.remember_token , :expires => self.current_<%= file_name %>.remember_token_expires_at }
+      end
+      redirect_back_or_default('/')
+      flash[:notice] = "Logged in successfully"
+    else
+      flash[:notice] = "Login failed"
+      render :action => 'new'
+    end
+  end
+
+  def destroy
+    self.current_<%= file_name %>.forget_me if logged_in?
+    cookies.delete :auth_token
+    reset_session
+    flash[:notice] = "You have been logged out."
+    redirect_back_or_default('/')
+  end
+  
+  def begin
+    # If the URL was unusable (either because of network conditions, a server error, 
+    # or that the response returned was not an OpenID identity page), the library 
+    # will return HTTP_FAILURE or PARSE_ERROR. Let the user know that the URL is unusable.
+    case open_id_request.status
+      when OpenID::Consumer::SUCCESS
+        # The URL was a valid identity URL. Now we just need to send a redirect
+        # to the server using the redirect_url the library created for us.
+
+        # redirect to the server
+        redirect_to open_id_request.redirect_url((request.protocol + request.host_with_port + "/"), complete_<%= controller_file_name %>_url)
+      else
+        flash[:error] = "Unable to find OpenID server for <q>#{params[:open_id_claimed_id]}</q>"
+        render :action => :new
+    end
+  end
+
+  def begin_error
+    flash[:error] =
+      "Unable to find OpenID server for <q>#{params[:open_id_claimed_id]}</q>"
+    render :action => :new
+  end
+
+  def complete
+    case open_id_response.status
+      when OpenID::Consumer::FAILURE
+        # In the case of failure, if info is non-nil, it is the URL that we were verifying. 
+        # We include it in the error message to help the user figure out what happened.
+        flash[:notice] = if open_id_response.identity_url
+          "Verification of #{open_id_response.identity_url} failed. "
+        else
+          "Verification failed. "
+        end
+        flash[:notice] += open_id_response.msg.to_s
+      when OpenID::Consumer::SUCCESS
+        # Success means that the transaction completed without error. If info is nil, 
+        # it means that the user cancelled the verification.
+        flash[:notice] = "You have successfully verified #{open_id_response.identity_url} as your identity."
+        if open_id_fields.any?
+          @<%= file_name %>   = <%= class_name %>.find_by_claimed_id(open_id_response.identity_url)
+          @<%= file_name %> ||= <%= class_name %>.new(:claimed_id => open_id_response.identity_url)
+          @<%= file_name %>.email = open_id_fields['email']    if open_id_fields['email']
+          @<%= file_name %>.nickname = open_id_fields['nickname'] if open_id_fields['nickname']
+          if @<%= file_name %>.save
+            self.current_<%= file_name %> = @<%= file_name %>
+            if params[:remember_me] == "1"
+              self.current_<%= file_name %>.remember_me
+              cookies[:auth_token] = { :value => self.current_<%= file_name %>.remember_token , :expires => self.current_<%= file_name %>.remember_token_expires_at }
+            end
+            flash[:notice] = "You have successfully verified #{open_id_response.identity_url} as your identity."
+            return redirect_back_or_default('/')
+          else
+            flash[:notice] = @<%= file_name %>.errors.full_messages.join('<br />')
+            render :action => 'new' and return
+          end
+        end
+      when OpenID::Consumer::CANCEL
+        flash[:notice] = "Verification cancelled."
+      else
+        flash[:notice] = "Unknown response status: #{open_id_response.status}"
+    end
+    redirect_to :action => 'new'
+  end
+end

data/templates/fixtures.yml

@@ -0,0 +1,15 @@
+quentin:
+  id: 1
+  email: quentin@example.com
+  salt: 7e3041ebc2fc05a40c60028e2c4901a81035d3cd
+  crypted_password: 00742970dc9e6319f8019fd54864d3ea740f04b1 # test
+  created_at: <%%= 5.days.ago.to_s :db %>
+<% if options[:include_activation] %>  activation_code: 8f24789ae988411ccf33ab0c30fe9106fab32e9b <% end %>
+<% if options[:include_activation] %>  activated_at: <%%= 5.days.ago.to_s :db %> <% end %>
+aaron:
+  id: 2
+  email: aaron@example.com
+  salt: 7e3041ebc2fc05a40c60028e2c4901a81035d3cd
+  crypted_password: 00742970dc9e6319f8019fd54864d3ea740f04b1 # test
+  created_at: <%%= 1.days.ago.to_s :db %>
+<% if options[:include_activation] %>  activation_code: 8f24789ae988411ccf33ab0c30fe9106fab32e9a <% end %>