one_click 0.1.0

data/Manifest

@@ -0,0 +1,13 @@
+README.rdoc
+Rakefile
+VERSION
+app/controllers/sessions_controller.rb
+app/models/one_click_twitter_service.rb
+app/models/one_click_user.rb
+app/models/twitter.rb
+config/routes.rb
+lib/one_click.rb
+lib/one_click/authenticators/oauth_authenticator.rb
+lib/one_click/controller_extensions.rb
+lib/one_click/services/twitter_service.rb
+Manifest

data/README.rdoc

@@ -0,0 +1,64 @@
+= OneClick
+
+Let your users register with one click using open standards for authenticating. Currently supporting only Twitter. Tested in Rails 2.3.5. Should work in all 2.3 version. Probably not Rails 3.
+
+Currently supporting only MongoMapper! Will support ActiveRecord and more platforms (Facebook, OpenID) eventually.
+
+== Requirements
+
+Needs twitter_oauth.
+
+  sudo gem install twitter_oauth
+
+== Installation
+
+  sudo gem install one_click
+
+environment.rb
+
+  config.gem "one_click"
+
+=== Configuration
+
+Add an initializer in config/initializers for example one_click_config.rb;
+
+  OneClick.config = {
+	:twitter => {
+		:key => 'your key',
+		:secret => 'your secret'
+	}
+  }
+
+=== User Model
+
+User model needs to extend OneClickUser and associate twitter (one), like so:
+
+  class User < OneClickUser
+	one :twitter
+  end
+
+The Twitter object is automatically maintained by the gem.
+
+== Usage
+
+Using the gem is easy. There are three defined routes:
+
+  map.login '/login/callback',	:controller => :sessions, :action => 'callback'
+  map.login '/login/:service',	:controller => :sessions, :action => 'login'
+  map.login '/logout',		:controller => :sessions, :action => 'logout'
+
+Access /login/twitter to login with Twitter. Once logged in, a new User is created with a twitter profile associated if it didn't already exist. The created User is blank.
+
+To access the currently logged in user simply call 'current_user'.
+
+There are three helper methods; 'requires_login', 'requires_logout' and 'logged_in?'. So to set up a page which requires login simply use a before filter;
+
+  class AdminController < ApplicationController
+	
+	before_filter :requires_login
+
+	def index
+		# Something nifty
+	end
+
+  end

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('one_click', '0.1.0') do |p|
+  p.description    = "Let your users register with one click using open standards for authenticating"
+  p.url            = "http://github.com/ArosME/one_click"
+  p.author         = "Arjen Oosterkamp"
+  p.email          = "mail@arjen.me"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end

data/VERSION

@@ -0,0 +1 @@
+0.1

data/lib/one_click/authenticators/oauth_authenticator.rb

@@ -0,0 +1,7 @@
+module OneClick
+	module Authenticators
+		class OAuth
+
+		end
+	end
+end

data/lib/one_click/controller_extensions.rb

@@ -0,0 +1,56 @@
+module OneClick
+	module ControllerExtensions
+		def self.included(base)
+			base.send :helper_method, :current_user, :referer, :requires_login, :requires_logout, :logged_in?
+		end
+
+		protected
+
+		def current_service
+			unless @current_service
+				if !session[:one_click] || !session[:one_click][:access]
+					service = cookies[:one_click_service]
+
+					access = {
+						:token => cookies[:one_click_access_token],
+						:secret => cookies[:one_click_access_secret]
+					}
+
+					OneClick.store_session(session, service, access) if service && access
+				end
+				
+				if session[:one_click]
+					@current_service = OneClick.get_service_model(session[:one_click][:service], { :access => session[:one_click][:access] }) if session[:one_click][:service] && session[:one_click][:access]
+				end
+			end
+
+			@current_service
+		end
+
+		def current_user
+			unless @current_user
+				@current_user = current_service.user if current_service
+			end
+
+			@current_user
+		end
+
+		def logged_in?
+			!!current_user
+		end
+
+		def requires_login
+			redirect_to root_url if !logged_in?
+		end
+		
+		def requires_logout
+			redirect_to root_url if logged_in?
+		end
+
+		def referer
+			return request.referer ? request.referer : root_url
+		end
+	end
+end
+
+ActionController::Base.send(:include, OneClick::ControllerExtensions)

data/lib/one_click/services/twitter_service.rb

@@ -0,0 +1,90 @@
+require 'twitter_oauth'
+
+module OneClick
+	module Services
+		class TwitterService
+			def initialize(config)
+				@config = config
+			end
+
+			def config
+				@config
+			end
+
+			def key
+				config[:key]
+			end
+
+			def secret
+				config[:secret]
+			end
+
+			def client
+				@client ||= TwitterOAuth::Client.new(
+					:consumer_key => key,
+					:consumer_secret => secret
+				)
+			end
+
+			def authenticated_client(options={})
+				access = options[:access]
+
+				return false if !access
+				
+				client = TwitterOAuth::Client.new(
+					:consumer_key => key,
+					:consumer_secret => secret,
+					:token => access[:token],
+					:secret => access[:secret]
+				)
+			end
+
+			def login(options={})
+				callback = options[:callback]
+
+				request_token = client.request_token(:oauth_callback => callback)
+				
+				return_object = {
+					:request => {
+						:token => request_token.token,
+						:secret => request_token.secret
+					},
+					:url => request_token.authorize_url
+				}
+			end
+
+			# Attemps to authorize with Twitter
+			def callback(options = {})
+				request = options[:request]
+				verifier = options[:params][:oauth_verifier]
+
+				return false if !request || !verifier
+
+				access_token = client.authorize(
+					request[:token],
+					request[:secret],
+					:oauth_verifier => verifier
+				)
+				
+				if client.authorized?
+					return return_object = {
+						:id => client.info['id'],
+						:data => client.info,
+						:access => {
+							:token => access_token.token,
+							:secret => access_token.secret
+						}
+					}
+				else
+					return false
+				end
+			end
+
+			def get_service_model(options={})
+				access = options[:access]
+				
+				Twitter.find_by_access_token_and_access_secret access[:token], access[:secret]
+			end
+		end
+	end
+end

data/lib/one_click.rb

@@ -0,0 +1,52 @@
+require 'oauth'
+require 'twitter_oauth'
+
+require 'one_click/controller_extensions'
+
+module OneClick
+	#VERSION = '0.0.1'
+
+	def self.config=(config)
+		@config = config
+	end
+
+	def self.config
+		@config
+	end
+	
+	def self.store_session(session, service, access)
+		session[:one_click] ||= {}
+
+		session[:one_click][:service] = service
+		session[:one_click][:access] = access
+	end
+
+	def self.store_cookies(cookies, service, access)
+		cookies[:one_click_service] = { :value => service, :expires => 30.days.from_now }
+		cookies[:one_click_access_token] = { :value => access[:token], :expires => 30.days.from_now }
+		cookies[:one_click_access_secret] = { :value => access[:secret], :expires => 30.days.from_now }
+	end
+
+	def self.get_service_model(service, options={})
+		self.get_service(service).get_service_model(options)
+	end
+
+	def self.login(service, options={})
+		self.get_service(service).login(options) if get_service(service)
+	end
+
+	def self.callback(service, options={})
+		self.get_service(service).callback(options)
+	end
+
+	def self.authenticated_client(service, options={})
+		self.get_service(service).authenticated_client(options)
+	end
+
+	def self.get_service(service)
+		case service
+			when 'twitter'
+				return self::Services::TwitterService.new(config[:twitter]) if config[:twitter]
+		end
+	end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: one_click
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Arjen Oosterkamp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-05 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Let your users register with one click using open standards for authenticating
+email: mail@arjen.me
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest
+- Rakefile
+- README.rdoc
+- VERSION
+files: 
+- lib/one_click/controller_extensions.rb
+- lib/one_click/authenticators/oauth_authenticator.rb
+- lib/one_click/services/twitter_service.rb
+- lib/one_click.rb
+- Manifest
+- Rakefile
+- README.rdoc
+- VERSION
+has_rdoc: true
+homepage: http://www.arjen.me/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- OneClick -- Easy OneClick authenticating
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Let your users register with one click using open standards for authenticating
+test_files: []
+