Replace Faraday with the HTTP gem

README.md

@@ -467,23 +467,6 @@ After configuration, requests can be made like so:
 client.update("I'm tweeting with @gem!")
 ```
 
-### Middleware
-The Faraday middleware stack is fully configurable and is exposed as a
-`Faraday::RackBuilder` object. You can modify the default middleware in-place:
-
-```ruby
-client.middleware.insert_after Twitter::Response::RaiseError, CustomMiddleware
-```
-
-A custom adapter may be set as part of a custom middleware stack:
-
-```ruby
-client.middleware = Faraday::RackBuilder.new do |faraday|
-  # Specify a middleware stack here
-  faraday.adapter :some_other_adapter
-end
-```
-
 ## Usage Examples
 All examples require an authenticated Twitter client. See the section on <a
 href="#configuration">configuration</a>.

Rakefile

@@ -31,7 +31,7 @@ end
 
 require 'yardstick/rake/verify'
 Yardstick::Rake::Verify.new do |verify|
-  verify.threshold = 59.7
+  verify.threshold = 59.9
 end
 
 task :default => [:spec, :rubocop, :verify_measurements]

etc/erd.dot

@@ -5,8 +5,6 @@ digraph classes {
 	ArgumentError [label="ArgumentError"]
 	Array [label="Array"]
 	Exception [label="Exception"]
-	Faraday__Middleware [label="Faraday::Middleware"]
-	Faraday__Response__Middleware [label="Faraday::Response::Middleware"]
 	Naught__BasicObject [label="Naught::BasicObject"]
 	StandardError [label="StandardError"]
 	Twitter__Arguments [label="Twitter::Arguments"]
@@ -34,7 +32,6 @@ digraph classes {
 	Twitter__Error__InternalServerError [label="Twitter::Error::InternalServerError"]
 	Twitter__Error__NotAcceptable [label="Twitter::Error::NotAcceptable"]
 	Twitter__Error__NotFound [label="Twitter::Error::NotFound"]
-	Twitter__Error__RequestTimeout [label="Twitter::Error::RequestTimeout"]
 	Twitter__Error__ServerError [label="Twitter::Error::ServerError"]
 	Twitter__Error__ServiceUnavailable [label="Twitter::Error::ServiceUnavailable"]
 	Twitter__Error__TooManyRequests [label="Twitter::Error::TooManyRequests"]
@@ -57,10 +54,6 @@ digraph classes {
 	Twitter__Place [label="Twitter::Place"]
 	Twitter__ProfileBanner [label="Twitter::ProfileBanner"]
 	Twitter__REST__Client [label="Twitter::REST::Client"]
-	Twitter__REST__Request__MultipartWithFile [label="Twitter::REST::Request::MultipartWithFile"]
-	Twitter__REST__Response__ParseErrorJson [label="Twitter::REST::Response::ParseErrorJson"]
-	Twitter__REST__Response__ParseJson [label="Twitter::REST::Response::ParseJson"]
-	Twitter__REST__Response__RaiseError [label="Twitter::REST::Response::RaiseError"]
 	Twitter__RateLimit [label="Twitter::RateLimit"]
 	Twitter__Relationship [label="Twitter::Relationship"]
 	Twitter__Request [label="Twitter::Request"]
@@ -88,8 +81,6 @@ digraph classes {
 	ArgumentError -> StandardError
 	Array -> Object
 	Exception -> Object
-	Faraday__Middleware -> Object
-	Faraday__Response__Middleware -> Faraday__Middleware
 	Naught__BasicObject -> Object
 	StandardError -> Exception
 	Twitter__Arguments -> Array
@@ -117,7 +108,6 @@ digraph classes {
 	Twitter__Error__InternalServerError -> Twitter__Error__ServerError
 	Twitter__Error__NotAcceptable -> Twitter__Error__ClientError
 	Twitter__Error__NotFound -> Twitter__Error__ClientError
-	Twitter__Error__RequestTimeout -> Twitter__Error__ClientError
 	Twitter__Error__ServerError -> Twitter__Error
 	Twitter__Error__ServiceUnavailable -> Twitter__Error__ServerError
 	Twitter__Error__TooManyRequests -> Twitter__Error__ClientError
@@ -140,10 +130,6 @@ digraph classes {
 	Twitter__Place -> Twitter__Base
 	Twitter__ProfileBanner -> Twitter__Base
 	Twitter__REST__Client -> Twitter__Client
-	Twitter__REST__Request__MultipartWithFile -> Faraday__Middleware
-	Twitter__REST__Response__ParseErrorJson -> Twitter__REST__Response__ParseJson
-	Twitter__REST__Response__ParseJson -> Faraday__Response__Middleware
-	Twitter__REST__Response__RaiseError -> Faraday__Response__Middleware
 	Twitter__RateLimit -> Twitter__Base
 	Twitter__Relationship -> Twitter__Base
 	Twitter__Request -> Object

lib/twitter/cursor.rb

@@ -43,7 +43,7 @@ def last?
 
     # @return [Hash]
     def fetch_next_page
-      response = @client.send(@request_method, @path, @options.merge(:cursor => next_cursor)).body
+      response = @client.send(@request_method, @path, @options.merge(:cursor => next_cursor))
       self.attrs = response
     end
 

lib/twitter/error.rb

@@ -32,11 +32,11 @@ module Code
     class << self
       # Create a new error from an HTTP response
       #
-      # @param response [Faraday::Response]
+      # @param response [HTTP::Response]
       # @return [Twitter::Error]
       def from_response(response)
-        message, code = parse_error(response.body)
-        new(message, response.response_headers, code)
+        message, code = parse_error(response.parse)
+        new(message, response.headers, code)
       end
 
       # @return [Hash]
@@ -47,7 +47,6 @@ def errors
           403 => Twitter::Error::Forbidden,
           404 => Twitter::Error::NotFound,
           406 => Twitter::Error::NotAcceptable,
-          408 => Twitter::Error::RequestTimeout,
           422 => Twitter::Error::UnprocessableEntity,
           429 => Twitter::Error::TooManyRequests,
           500 => Twitter::Error::InternalServerError,
@@ -68,7 +67,7 @@ def forbidden_messages
     private
 
       def parse_error(body)
-        if body.nil?
+        if body.nil? || body.empty?
           ['', nil]
         elsif body[:error]
           [body[:error], nil]
@@ -129,9 +128,6 @@ class NotFound < ClientError; end
     # Raised when Twitter returns the HTTP status code 406
     class NotAcceptable < ClientError; end
 
-    # Raised when Twitter returns the HTTP status code 408
-    class RequestTimeout < ClientError; end
-
     # Raised when Twitter returns the HTTP status code 422
     class UnprocessableEntity < ClientError; end
 

lib/twitter/request.rb

@@ -19,7 +19,7 @@ def initialize(client, request_method, path, options = {})
 
     # @return [Hash]
     def perform
-      @client.send(@request_method, @path, @options).body
+      @client.send(@request_method, @path, @options)
     end
 
     # @param klass [Class]

lib/twitter/rest/client.rb

@@ -1,14 +1,10 @@
 require 'base64'
-require 'faraday'
-require 'faraday/request/multipart'
+require 'http'
 require 'json'
 require 'timeout'
 require 'twitter/client'
 require 'twitter/error'
 require 'twitter/rest/api'
-require 'twitter/rest/request/multipart_with_file'
-require 'twitter/rest/response/parse_json'
-require 'twitter/rest/response/raise_error'
 
 module Twitter
   module REST
@@ -22,51 +18,16 @@ class Client < Twitter::Client
       attr_writer :connection_options, :middleware
       ENDPOINT = 'https://api.twitter.com'
 
-      def connection_options
-        @connection_options ||= {
-          :builder => middleware,
-          :headers => {
-            :accept => 'application/json',
-            :user_agent => user_agent,
-          },
-          :request => {
-            :open_timeout => 10,
-            :timeout => 30,
-          },
-        }
-      end
-
-      # @note Faraday's middleware stack implementation is comparable to that of Rack middleware.  The order of middleware is important: the first middleware on the list wraps all others, while the last middleware is the innermost one.
-      # @see https://github.com/technoweenie/faraday#advanced-middleware-usage
-      # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
-      # @return [Faraday::RackBuilder]
-      def middleware
-        @middleware ||= Faraday::RackBuilder.new do |faraday|
-          # Convert file uploads to Faraday::UploadIO objects
-          faraday.request :multipart_with_file
-          # Checks for files in the payload, otherwise leaves everything untouched
-          faraday.request :multipart
-          # Encodes as "application/x-www-form-urlencoded" if not already encoded
-          faraday.request :url_encoded
-          # Handle error responses
-          faraday.response :raise_error
-          # Parse JSON response bodies
-          faraday.response :parse_json
-          # Set default HTTP adapter
-          faraday.adapter :net_http
-        end
-      end
-
       # Perform an HTTP GET request
       def get(path, params = {})
-        headers = request_headers(:get, path, params)
-        request(:get, path, params, headers)
+        header = auth_header(:get, path, params)
+        request(:get, path, {:params => params}, :authorization => header)
       end
 
       # Perform an HTTP POST request
       def post(path, params = {})
-        headers = params.values.any? { |value| value.respond_to?(:to_io) } ? request_headers(:post, path, params, {}) : request_headers(:post, path, params)
-        request(:post, path, params, headers)
+        header = params.values.any? { |value| value.respond_to?(:to_io) } ? auth_header(:post, path, params, {}) : auth_header(:post, path, params)
+        request(:post, path, {:form => params}, :authorization => header)
       end
 
       # @return [Boolean]
@@ -81,32 +42,30 @@ def credentials?
 
     private
 
-      # Returns a Faraday::Connection object
-      #
-      # @return [Faraday::Connection]
-      def connection
-        @connection ||= Faraday.new(ENDPOINT, connection_options)
+      def request(method, path, params = {}, headers = {})
+        response = HTTP.with(headers).send(method, ENDPOINT + path, params)
+        error = error(response)
+        fail(error) if error
+        response.parse
       end
 
-      def request(method, path, params = {}, headers = {})
-        connection.send(method.to_sym, path, params) { |request| request.headers.update(headers) }.env
-      rescue Faraday::Error::TimeoutError, Timeout::Error => error
-        raise(Twitter::Error::RequestTimeout.new(error))
-      rescue Faraday::Error::ClientError, JSON::ParserError => error
-        fail(Twitter::Error.new(error))
+      def error(response)
+        klass = Twitter::Error.errors[response.code]
+        if klass == Twitter::Error::Forbidden
+          forbidden_error(response)
+        elsif !klass.nil?
+          klass.from_response(response)
+        end
       end
 
-      def request_headers(method, path, params = {}, signature_params = params)
-        bearer_token_request = params.delete(:bearer_token_request)
-        headers = {}
-        if bearer_token_request
-          headers[:accept]        = '*/*'
-          headers[:authorization] = bearer_token_credentials_auth_header
-          headers[:content_type]  = 'application/x-www-form-urlencoded; charset=UTF-8'
+      def forbidden_error(response)
+        error = Twitter::Error::Forbidden.from_response(response)
+        klass = Twitter::Error.forbidden_messages[error.message]
+        if klass
+          klass.from_response(response)
         else
-          headers[:authorization] = auth_header(method, path, params, signature_params)
+          error
         end
-        headers
       end
 
       def auth_header(method, path, params = {}, signature_params = params)
@@ -118,23 +77,10 @@ def auth_header(method, path, params = {}, signature_params = params)
         end
       end
 
-      # Generates authentication header for a bearer token request
-      #
-      # @return [String]
-      def bearer_token_credentials_auth_header
-        basic_auth_token = strict_encode64("#{@consumer_key}:#{@consumer_secret}")
-        "Basic #{basic_auth_token}"
-      end
-
       def bearer_auth_header
         token = bearer_token.is_a?(Twitter::Token) && bearer_token.bearer? ? bearer_token.access_token : bearer_token
         "Bearer #{token}"
       end
-
-      # Base64.strict_encode64 is not available on Ruby 1.8.7
-      def strict_encode64(str)
-        Base64.encode64(str).gsub("\n", '')
-      end
     end
   end
 end

lib/twitter/rest/friends_and_followers.rb

@@ -273,7 +273,7 @@ def friends(*args)
       # @return [Array<Integer>]
       # @param options [Hash] A customizable set of options.
       def no_retweet_ids(options = {})
-        get('/1.1/friendships/no_retweets/ids.json', options).body.collect(&:to_i)
+        get('/1.1/friendships/no_retweets/ids.json', options).collect(&:to_i)
       end
       alias_method :no_retweets_ids, :no_retweet_ids
     end

lib/twitter/rest/help.rb

@@ -38,7 +38,7 @@ def languages(options = {})
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
       # @return [String]
       def privacy(options = {})
-        get('/1.1/help/privacy.json', options).body[:privacy]
+        get('/1.1/help/privacy.json', options)[:privacy]
       end
 
       # Returns {https://twitter.com/tos Twitter's Terms of Service}
@@ -49,7 +49,7 @@ def privacy(options = {})
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
       # @return [String]
       def tos(options = {})
-        get('/1.1/help/tos.json', options).body[:tos]
+        get('/1.1/help/tos.json', options)[:tos]
       end
     end
   end

lib/twitter/rest/oauth.rb

@@ -1,6 +1,5 @@
 require 'twitter/request'
 require 'twitter/rest/utils'
-require 'twitter/rest/response/parse_error_json'
 require 'twitter/token'
 
 module Twitter
@@ -24,9 +23,12 @@ module OAuth
       #   client = Twitter::REST::Client.new(:consumer_key => "abc", :consumer_secret => 'def')
       #   bearer_token = client.token
       def token(options = {})
-        options[:bearer_token_request] = true
         options[:grant_type] ||= 'client_credentials'
-        perform_with_object(:post, '/oauth2/token', options, Twitter::Token)
+        headers = {}
+        headers[:accept]        = '*/*'
+        headers[:authorization] = "Basic #{strict_encode64("#{@consumer_key}:#{@consumer_secret}")}"
+        response = HTTP.with(headers).post('https://api.twitter.com/oauth2/token', :form => options)
+        Twitter::Token.new(response.parse)
       end
       alias_method :bearer_token, :token
 
@@ -53,12 +55,17 @@ def invalidate_token(access_token, options = {})
       # @raise [Twitter::Error::Unauthorized] Error raised when supplied user credentials are not valid.
       # @return [String] The token string.
       def reverse_token
-        conn = connection.dup
-        conn.builder.swap(4, Twitter::REST::Response::ParseErrorJson)
-        response = conn.post('/oauth/request_token?x_auth_mode=reverse_auth') do |request|
-          request.headers[:authorization] = oauth_auth_header(:post, 'https://api.twitter.com/oauth/request_token', :x_auth_mode => 'reverse_auth').to_s
-        end
-        response.body
+        uri = 'https://api.twitter.com/oauth/request_token'
+        options = {:x_auth_mode => 'reverse_auth'}
+        headers = {:authorization => oauth_auth_header(:post, uri, options).to_s}
+        HTTP.with(headers).post(uri, :params => options).to_s
+      end
+
+    private
+
+      # Base64.strict_encode64 is not available on Ruby 1.8.7
+      def strict_encode64(str)
+        Base64.encode64(str).gsub("\n", '')
       end
     end
   end