twitter-login 0.3.1 → 0.4.0

data/lib/twitter/login.rb

@@ -10,36 +10,38 @@ class Twitter::Login
   attr_reader :options
   
   class << self
-    attr_accessor :consumer_key, :secret
+    attr_accessor :consumer_key, :secret, :site
   end
   
-  DEFAULTS = { :login_path => '/login', :return_to => '/' }
+  DEFAULTS = {
+    :return_to => '/',
+    :site => 'http://api.twitter.com',
+    :authorize_path => '/oauth/authenticate'
+  }
   
-  def initialize(app, options)
-    @app = app
+  def initialize(options)
     @options = DEFAULTS.merge options
     self.class.consumer_key, self.class.secret = @options[:consumer_key], @options[:secret]
+    self.class.site = @options[:site]
+  end
+  
+  def login_handler(options = {})
+    @options.update options
+    return self
   end
   
   def call(env)
     request = Request.new(env)
-    
-    if request.get? and request.path == options[:login_path]
-      @oauth = nil
-      # detect if Twitter redirected back here
-      if request[:oauth_verifier]
-        handle_twitter_authorization(request) do
-          @app.call(env)
-        end
-      elsif request[:denied]
-        # user refused to log in with Twitter, so give up
-        handle_denied_access(request)
-      else
-        # user clicked to login; send them to Twitter
-        redirect_to_twitter(request)
-      end
+  
+    if request[:oauth_verifier]
+      # user authorized the app
+      handle_twitter_authorization(request)
+    elsif request[:denied]
+      # user refused to log in with Twitter
+      handle_denied_access(request)
     else
-      @app.call(env)
+      # starting the login process; send user to Twitter
+      redirect_to_twitter(request)
     end
   end
   
@@ -50,7 +52,7 @@ class Twitter::Login
     
     def twitter_oauth
       OAuth::Consumer.new Twitter::Login.consumer_key, Twitter::Login.secret,
-        :site => 'http://api.twitter.com'
+        :site => Twitter::Login.site
     end
     
     def twitter_user
@@ -92,36 +94,23 @@ class Twitter::Login
     # create a request token and store its parameter in session
     request_token = oauth.get_request_token(:oauth_callback => request.url)
     request.session[:twitter_request_token] = [request_token.token, request_token.secret]
+    
     # redirect to Twitter authorization page
     redirect request_token.authorize_url
   end
   
   def handle_twitter_authorization(request)
     access_token = authorize_from_request(request)
-    response = access_token.get('/1/account/verify_credentials.json')
     
     # get and store authenticated user's info from Twitter
-    request.session[:twitter_user] = user_hash_from_response(response)
-    
-    # pass the request down to the main app
-    response = begin
-      yield
-    rescue
-      raise unless $!.class.name == 'ActionController::RoutingError'
-      [404]
-    end
+    response = access_token.get('/1/account/verify_credentials.json')
+    request.session[:twitter_user] = Yajl::Parser.parse response.body
     
-    # check if the app implemented anything at :login_path
-    if response[0].to_i == 404
-      # if not, redirect to :return_to path
-      redirect_to_return_path(request)
-    else
-      # use the response from the app without modification
-      response
-    end
+    redirect_to_return_path(request)
   end
   
   def handle_denied_access(request)
+    # cleanup session and set an error identifier
     request.session[:twitter_request_token] = nil # work around a Rails 2.3.5 bug
     request.session.delete(:twitter_request_token)
     request.session[:twitter_error] = 'user_denied'
@@ -134,11 +123,11 @@ class Twitter::Login
   def authorize_from_request(request)
     rtoken, rsecret = request.session[:twitter_request_token]
     request_token = OAuth::RequestToken.new(oauth, rtoken, rsecret)
-    access_token = request_token.get_access_token(:oauth_verifier => request[:oauth_verifier])
     
-    request.session.delete(:twitter_request_token)
-    request.session[:twitter_access_token] = [access_token.token, access_token.secret]
-    return access_token
+    request_token.get_access_token(:oauth_verifier => request[:oauth_verifier]).tap do |access_token|
+      request.session.delete(:twitter_request_token)
+      request.session[:twitter_access_token] = [access_token.token, access_token.secret]
+    end
   end
   
   def redirect_to_return_path(request)
@@ -150,19 +139,7 @@ class Twitter::Login
   end
   
   def oauth
-    @oauth ||= OAuth::Consumer.new(options[:consumer_key], options[:secret],
-      :site => 'http://api.twitter.com',
-      :authorize_path => '/oauth/authenticate'
-    )
-  end
-  
-  def user_hash_from_response(api_response)
-    parse_response(api_response).reject { |key, _|
-      key == 'status' or key =~ /^profile_|_color$/
-    }
-  end
-  
-  def parse_response(api_response)
-    Yajl::Parser.parse api_response.body
+    OAuth::Consumer.new options[:consumer_key], options[:secret],
+      :site => options[:site], :authorize_path => options[:authorize_path]
   end
 end

data/spec/login_spec.rb

@@ -44,35 +44,38 @@ describe Twitter::Login do
   
   it "should login with Twitter" do
     request_token = mock('Request Token', :authorize_url => 'http://disney.com/oauth', :token => 'abc', :secret => '123')
-    oauth = mock_oauth('Twitter OAuth')
-    oauth.should_receive(:get_request_token).with(:oauth_callback => 'http://example.org/login').and_return(request_token)
+    oauth = mock_oauth('Twitter OAuth', :request_token => request_token)
+    oauth.should_receive(:set_callback_url).with('http://example.org/login')
     
     get('/login', :lint => true)
     response.status.should == 302
     response['Location'].should == 'http://disney.com/oauth'
     response.body.should be_empty
-    session[:twitter_request_token].should == ['abc', '123']
+    session[:request_token].should == ['abc', '123']
   end
   
   it "should authorize with Twitter" do
-    oauth = mock_oauth('Twitter OAuth')
-    request_token = mock('Request Token')
-    OAuth::RequestToken.should_receive(:new).with(oauth, 'abc', '123').and_return(request_token)
+    consumer = mock('OAuth consumer')
     access_token = mock('Access Token', :token => 'access1', :secret => '42')
-    request_token.should_receive(:get_access_token).with(:oauth_verifier => 'allrighty').and_return(access_token)
+    oauth = mock_oauth('Twitter OAuth', :access_token => access_token, :consumer => consumer)
+    oauth.should_receive(:authorize_from_request).with('abc', '123', 'allrighty')
     
-    payload = { :screen_name => 'faker', :name => 'Fake Jr.', :followers_count => '13',
-      :profile_image_url => 'http://disney.com/mickey.png', :friends_count => '6', :statuses_count => '52' }
+    twitter = mock('Twitter Base')
+    Twitter::Base.should_receive(:new).with(oauth).and_return(twitter)
     
-    http_response = mock('HTTP response', :body => Yajl::Encoder.encode(payload))
-    access_token.should_receive(:get).with('/1/account/verify_credentials.json').and_return(http_response)
+    twitter.should_receive(:verify_credentials).and_return {
+      Hashie::Mash.new :screen_name => 'faker',
+        :name => 'Fake Jr.', :profile_image_url => 'http://disney.com/mickey.png',
+        :followers_count => '13', :friends_count => '6', :statuses_count => '52'
+    }
     
-    session_data = {:twitter_request_token => ['abc', '123']}
+    session_data = {:request_token => ['abc', '123']}
     get('/login?oauth_verifier=allrighty', build_session(session_data).update(:lint => true))
     response.status.should == 302
     response['Location'].should == 'http://example.org/'
-    session[:twitter_request_token].should be_nil
-    session[:twitter_access_token].should == ['access1', '42']
+    session[:request_token].should be_nil
+    session[:access_token].should == ['access1', '42']
+    session[:oauth_consumer].should be_nil
     
     current_user = session[:twitter_user]
     current_user['screen_name'].should == 'faker'
@@ -83,7 +86,7 @@ describe Twitter::Login do
     get('/login?denied=OMG', build_session(session_data).update(:lint => true))
     response.status.should == 302
     response['Location'].should == 'http://example.org/'
-    session[:twitter_request_token].should be_nil
+    session[:request_token].should be_nil
   end
   
   protected
@@ -121,7 +124,7 @@ describe Twitter::Login do
   
   def mock_oauth(*args)
     consumer = mock(*args)
-    OAuth::Consumer.should_receive(:new).and_return(consumer)
+    Twitter::OAuth.should_receive(:new).and_return(consumer)
     consumer
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: twitter-login
 version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: 
+  hash: 15
+  prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-17 00:00:00 +01:00
+date: 2010-09-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -140,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Rack middleware to provide login functionality through Twitter