oauth-instructure 0.4.8

data/lib/oauth/client.rb

@@ -0,0 +1,4 @@
+module OAuth
+  module Client
+  end
+end

data/lib/oauth/client/action_pack.rb

@@ -0,0 +1,9 @@
+require 'oauth/client/helper'
+# check for Rails 3 support
+if defined? ActionDispatch
+  require 'oauth/request_proxy/action_dispatch_request'
+  require 'action_dispatch/testing/test_process'
+else
+  require 'oauth/request_proxy/action_controller_request'
+  require 'action_controller/test_process'
+end

data/lib/oauth/client/em_http.rb

@@ -0,0 +1,120 @@
+require 'em-http'
+require 'oauth/helper'
+require 'oauth/client/helper'
+require 'oauth/request_proxy/em_http_request'
+
+# Extensions for em-http so that we can use consumer.sign! with an EventMachine::HttpClient
+# instance. This is purely syntactic sugar.
+class EventMachine::HttpClient
+
+  attr_reader :oauth_helper
+
+  # Add the OAuth information to an HTTP request. Depending on the <tt>options[:scheme]</tt> setting
+  # this may add a header, additional query string parameters, or additional POST body parameters.
+  # The default scheme is +header+, in which the OAuth parameters as put into the +Authorization+
+  # header.
+  #
+  # * http - Configured Net::HTTP instance, ignored in this scenario except for getting host.
+  # * consumer - OAuth::Consumer instance
+  # * token - OAuth::Token instance
+  # * options - Request-specific options (e.g. +request_uri+, +consumer+, +token+, +scheme+,
+  #   +signature_method+, +nonce+, +timestamp+)
+  #
+  # This method also modifies the <tt>User-Agent</tt> header to add the OAuth gem version.
+  #
+  # See Also: {OAuth core spec version 1.0, section 5.4.1}[http://oauth.net/core/1.0#rfc.section.5.4.1]
+  def oauth!(http, consumer = nil, token = nil, options = {})
+    options = { :request_uri      => normalized_oauth_uri(http),
+                :consumer         => consumer,
+                :token            => token,
+                :scheme           => 'header',
+                :signature_method => nil,
+                :nonce            => nil,
+                :timestamp        => nil }.merge(options)
+
+    @oauth_helper = OAuth::Client::Helper.new(self, options)
+    self.__send__(:"set_oauth_#{options[:scheme]}")
+  end
+
+  # Create a string suitable for signing for an HTTP request. This process involves parameter
+  # normalization as specified in the OAuth specification. The exact normalization also depends
+  # on the <tt>options[:scheme]</tt> being used so this must match what will be used for the request
+  # itself. The default scheme is +header+, in which the OAuth parameters as put into the +Authorization+
+  # header.
+  #
+  # * http - Configured Net::HTTP instance
+  # * consumer - OAuth::Consumer instance
+  # * token - OAuth::Token instance
+  # * options - Request-specific options (e.g. +request_uri+, +consumer+, +token+, +scheme+,
+  #   +signature_method+, +nonce+, +timestamp+)
+  #
+  # See Also: {OAuth core spec version 1.0, section 9.1.1}[http://oauth.net/core/1.0#rfc.section.9.1.1]
+  def signature_base_string(http, consumer = nil, token = nil, options = {})
+    options = { :request_uri      => normalized_oauth_uri(http),
+                :consumer         => consumer,
+                :token            => token,
+                :scheme           => 'header',
+                :signature_method => nil,
+                :nonce            => nil,
+                :timestamp        => nil }.merge(options)
+
+    OAuth::Client::Helper.new(self, options).signature_base_string
+  end
+
+  # This code was lifted from the em-http-request because it was removed from
+  # the gem June 19, 2010
+  # see: http://github.com/igrigorik/em-http-request/commit/d536fc17d56dbe55c487eab01e2ff9382a62598b
+  def normalize_uri
+    @normalized_uri ||= begin
+      uri = @uri.dup
+      encoded_query = encode_query(@uri, @options[:query])
+      path, query = encoded_query.split("?", 2)
+      uri.query = query unless encoded_query.empty?
+      uri.path  = path
+      uri
+    end
+  end
+
+  protected
+
+  def combine_query(path, query, uri_query)
+    combined_query = if query.kind_of?(Hash)
+      query.map { |k, v| encode_param(k, v) }.join('&')
+    else
+      query.to_s
+    end
+    if !uri_query.to_s.empty?
+      combined_query = [combined_query, uri_query].reject {|part| part.empty?}.join("&")
+    end
+    combined_query.to_s.empty? ? path : "#{path}?#{combined_query}"
+  end
+
+  # Since we expect to get the host etc details from the http instance (...),
+  # we create a fake url here. Surely this is a horrible, horrible idea?
+  def normalized_oauth_uri(http)
+    uri = URI.parse(normalize_uri.path)
+    uri.host = http.address
+    uri.port = http.port
+
+    if http.respond_to?(:use_ssl?) && http.use_ssl?
+      uri.scheme = "https"
+    else
+      uri.scheme = "http"
+    end
+    uri.to_s
+  end
+
+  def set_oauth_header
+    headers = (self.options[:head] ||= {})
+    headers['Authorization'] = @oauth_helper.header
+  end
+
+  def set_oauth_body
+    raise NotImplementedError, 'please use the set_oauth_header method instead'
+  end
+
+  def set_oauth_query_string
+    raise NotImplementedError, 'please use the set_oauth_header method instead'
+  end
+
+end

data/lib/oauth/client/helper.rb

@@ -0,0 +1,91 @@
+require 'oauth/client'
+require 'oauth/consumer'
+require 'oauth/helper'
+require 'oauth/token'
+require 'oauth/signature/hmac/sha1'
+
+module OAuth::Client
+  class Helper
+    include OAuth::Helper
+
+    def initialize(request, options = {})
+      @request = request
+      @options = options
+      @options[:signature_method] ||= 'HMAC-SHA1'
+    end
+
+    def options
+      @options
+    end
+
+    def nonce
+      options[:nonce] ||= generate_key
+    end
+
+    def timestamp
+      options[:timestamp] ||= generate_timestamp
+    end
+
+    def oauth_parameters
+      {
+        'oauth_body_hash'        => options[:body_hash],
+        'oauth_callback'         => options[:oauth_callback],
+        'oauth_consumer_key'     => options[:consumer].key,
+        'oauth_token'            => options[:token] ? options[:token].token : '',
+        'oauth_signature_method' => options[:signature_method],
+        'oauth_timestamp'        => timestamp,
+        'oauth_nonce'            => nonce,
+        'oauth_verifier'         => options[:oauth_verifier],
+        'oauth_version'          => (options[:oauth_version] || '1.0'),
+        'oauth_session_handle'   => options[:oauth_session_handle]
+      }.reject { |k,v| v.to_s == "" }
+    end
+
+    def signature(extra_options = {})
+      OAuth::Signature.sign(@request, { :uri      => options[:request_uri],
+                                        :consumer => options[:consumer],
+                                        :token    => options[:token],
+                                        :unsigned_parameters => options[:unsigned_parameters]
+      }.merge(extra_options) )
+    end
+
+    def signature_base_string(extra_options = {})
+      OAuth::Signature.signature_base_string(@request, { :uri        => options[:request_uri],
+                                                         :consumer   => options[:consumer],
+                                                         :token      => options[:token],
+                                                         :parameters => oauth_parameters}.merge(extra_options) )
+    end
+
+    def hash_body
+      @options[:body_hash] = OAuth::Signature.body_hash(@request, :parameters => oauth_parameters)
+    end
+
+    def amend_user_agent_header(headers)
+      @oauth_ua_string ||= "OAuth gem v#{OAuth::VERSION}"
+      # Net::HTTP in 1.9 appends Ruby
+      if headers['User-Agent'] && headers['User-Agent'] != 'Ruby'
+        headers['User-Agent'] += " (#{@oauth_ua_string})"
+      else
+        headers['User-Agent'] = @oauth_ua_string
+      end
+    end
+
+    def header
+      parameters = oauth_parameters
+      parameters.merge!('oauth_signature' => signature(options.merge(:parameters => parameters)))
+
+      header_params_str = parameters.sort.map { |k,v| "#{k}=\"#{escape(v)}\"" }.join(', ')
+
+      realm = "realm=\"#{options[:realm]}\", " if options[:realm]
+      "OAuth #{realm}#{header_params_str}"
+    end
+
+    def parameters
+      OAuth::RequestProxy.proxy(@request).parameters
+    end
+
+    def parameters_with_oauth
+      oauth_parameters.merge(parameters)
+    end
+  end
+end

data/lib/oauth/client/net_http.rb

@@ -0,0 +1,120 @@
+require 'oauth/helper'
+require 'oauth/client/helper'
+require 'oauth/request_proxy/net_http'
+
+class Net::HTTPGenericRequest
+  include OAuth::Helper
+
+  attr_reader :oauth_helper
+
+  # Add the OAuth information to an HTTP request. Depending on the <tt>options[:scheme]</tt> setting
+  # this may add a header, additional query string parameters, or additional POST body parameters.
+  # The default scheme is +header+, in which the OAuth parameters as put into the +Authorization+
+  # header.
+  #
+  # * http - Configured Net::HTTP instance
+  # * consumer - OAuth::Consumer instance
+  # * token - OAuth::Token instance
+  # * options - Request-specific options (e.g. +request_uri+, +consumer+, +token+, +scheme+,
+  #   +signature_method+, +nonce+, +timestamp+)
+  #
+  # This method also modifies the <tt>User-Agent</tt> header to add the OAuth gem version.
+  #
+  # See Also: {OAuth core spec version 1.0, section 5.4.1}[http://oauth.net/core/1.0#rfc.section.5.4.1],
+  #           {OAuth Request Body Hash 1.0 Draft 4}[http://oauth.googlecode.com/svn/spec/ext/body_hash/1.0/drafts/4/spec.html]
+  def oauth!(http, consumer = nil, token = nil, options = {})
+    helper_options = oauth_helper_options(http, consumer, token, options)
+    @oauth_helper = OAuth::Client::Helper.new(self, helper_options)
+    @oauth_helper.amend_user_agent_header(self)
+    @oauth_helper.hash_body if oauth_body_hash_required?
+    self.send("set_oauth_#{helper_options[:scheme]}")
+  end
+
+  # Create a string suitable for signing for an HTTP request. This process involves parameter
+  # normalization as specified in the OAuth specification. The exact normalization also depends
+  # on the <tt>options[:scheme]</tt> being used so this must match what will be used for the request
+  # itself. The default scheme is +header+, in which the OAuth parameters as put into the +Authorization+
+  # header.
+  #
+  # * http - Configured Net::HTTP instance
+  # * consumer - OAuth::Consumer instance
+  # * token - OAuth::Token instance
+  # * options - Request-specific options (e.g. +request_uri+, +consumer+, +token+, +scheme+,
+  #   +signature_method+, +nonce+, +timestamp+)
+  #
+  # See Also: {OAuth core spec version 1.0, section 9.1.1}[http://oauth.net/core/1.0#rfc.section.9.1.1],
+  #           {OAuth Request Body Hash 1.0 Draft 4}[http://oauth.googlecode.com/svn/spec/ext/body_hash/1.0/drafts/4/spec.html]
+  def signature_base_string(http, consumer = nil, token = nil, options = {})
+    helper_options = oauth_helper_options(http, consumer, token, options)
+    oauth_helper = OAuth::Client::Helper.new(self, helper_options)
+    oauth_helper.hash_body if oauth_body_hash_required?
+    oauth_helper.signature_base_string
+  end
+
+private
+
+  def oauth_helper_options(http, consumer, token, options)
+    { :request_uri      => oauth_full_request_uri(http,options),
+      :consumer         => consumer,
+      :token            => token,
+      :scheme           => 'header',
+      :signature_method => nil,
+      :nonce            => nil,
+      :timestamp        => nil }.merge(options)
+  end
+
+  def oauth_full_request_uri(http,options)
+    uri = URI.parse(self.path)
+    uri.host = http.address
+    uri.port = http.port
+
+    if options[:request_endpoint] && options[:site]
+      is_https = options[:site].match(%r(^https://))
+      uri.host = options[:site].gsub(%r(^https?://), '')
+      uri.port ||= is_https ? 443 : 80
+    end
+
+    if http.respond_to?(:use_ssl?) && http.use_ssl?
+      uri.scheme = "https"
+    else
+      uri.scheme = "http"
+    end
+
+    uri.to_s
+  end
+
+  def oauth_body_hash_required?
+    request_body_permitted? && !content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
+  end
+
+  def set_oauth_header
+    self['Authorization'] = @oauth_helper.header
+  end
+
+  # FIXME: if you're using a POST body and query string parameters, this method
+  # will move query string parameters into the body unexpectedly. This may
+  # cause problems with non-x-www-form-urlencoded bodies submitted to URLs
+  # containing query string params. If duplicate parameters are present in both
+  # places, all instances should be included when calculating the signature
+  # base string.
+
+  def set_oauth_body
+    self.set_form_data(@oauth_helper.stringify_keys(@oauth_helper.parameters_with_oauth))
+    params_with_sig = @oauth_helper.parameters.merge(:oauth_signature => @oauth_helper.signature)
+    self.set_form_data(@oauth_helper.stringify_keys(params_with_sig))
+  end
+
+  def set_oauth_query_string
+    oauth_params_str = @oauth_helper.oauth_parameters.map { |k,v| [escape(k), escape(v)] * "=" }.join("&")
+    uri = URI.parse(path)
+    if uri.query.to_s == ""
+      uri.query = oauth_params_str
+    else
+      uri.query = uri.query + "&" + oauth_params_str
+    end
+
+    @path = uri.to_s
+
+    @path << "&oauth_signature=#{escape(oauth_helper.signature)}"
+  end
+end

data/lib/oauth/consumer.rb

@@ -0,0 +1,389 @@
+require 'net/http'
+require 'net/https'
+require 'oauth/oauth'
+require 'oauth/client/net_http'
+require 'oauth/errors'
+require 'cgi'
+
+module OAuth
+  class Consumer
+    # determine the certificate authority path to verify SSL certs
+    CA_FILES = %w(/etc/ssl/certs/ca-certificates.crt /usr/share/curl/curl-ca-bundle.crt)
+    CA_FILES.each do |ca_file|
+      if File.exists?(ca_file)
+        CA_FILE = ca_file
+        break
+      end
+    end
+    CA_FILE = nil unless defined?(CA_FILE)
+
+    @@default_options = {
+      # Signature method used by server. Defaults to HMAC-SHA1
+      :signature_method   => 'HMAC-SHA1',
+
+      # default paths on site. These are the same as the defaults set up by the generators
+      :request_token_path => '/oauth/request_token',
+      :authorize_path     => '/oauth/authorize',
+      :access_token_path  => '/oauth/access_token',
+
+      :proxy              => nil,
+      # How do we send the oauth values to the server see
+      # http://oauth.net/core/1.0/#consumer_req_param for more info
+      #
+      # Possible values:
+      #
+      #   :header - via the Authorize header (Default) ( option 1. in spec)
+      #   :body - url form encoded in body of POST request ( option 2. in spec)
+      #   :query_string - via the query part of the url ( option 3. in spec)
+      :scheme        => :header,
+
+      # Default http method used for OAuth Token Requests (defaults to :post)
+      :http_method   => :post,
+
+      # Add a custom ca_file for consumer
+      # :ca_file       => '/etc/certs.pem'
+
+      :oauth_version => "1.0"
+    }
+
+    attr_accessor :options, :key, :secret
+    attr_writer   :site, :http
+
+    # Create a new consumer instance by passing it a configuration hash:
+    #
+    #   @consumer = OAuth::Consumer.new(key, secret, {
+    #     :site               => "http://term.ie",
+    #     :scheme             => :header,
+    #     :http_method        => :post,
+    #     :request_token_path => "/oauth/example/request_token.php",
+    #     :access_token_path  => "/oauth/example/access_token.php",
+    #     :authorize_path     => "/oauth/example/authorize.php"
+    #    })
+    #
+    # Start the process by requesting a token
+    #
+    #   @request_token = @consumer.get_request_token
+    #   session[:request_token] = @request_token
+    #   redirect_to @request_token.authorize_url
+    #
+    # When user returns create an access_token
+    #
+    #   @access_token = @request_token.get_access_token
+    #   @photos=@access_token.get('/photos.xml')
+    #
+    def initialize(consumer_key, consumer_secret, options = {})
+      @key    = consumer_key
+      @secret = consumer_secret
+
+      # ensure that keys are symbols
+      @options = @@default_options.merge(options.inject({}) do |opts, (key, value)|
+        opts[key.to_sym] = value
+        opts
+      end)
+    end
+
+    # The default http method
+    def http_method
+      @http_method ||= @options[:http_method] || :post
+    end
+
+    # The HTTP object for the site. The HTTP Object is what you get when you do Net::HTTP.new
+    def http
+      @http ||= create_http
+    end
+
+    # Contains the root URI for this site
+    def uri(custom_uri = nil)
+      if custom_uri
+        @uri  = custom_uri
+        @http = create_http # yike, oh well. less intrusive this way
+      else  # if no custom passed, we use existing, which, if unset, is set to site uri
+        @uri ||= URI.parse(site)
+      end
+    end
+
+    def get_access_token(request_token, request_options = {}, *arguments, &block)
+      response = token_request(http_method, (access_token_url? ? access_token_url : access_token_path), request_token, request_options, *arguments, &block)
+      OAuth::AccessToken.from_hash(self, response)
+    end
+
+    # Makes a request to the service for a new OAuth::RequestToken
+    #
+    #  @request_token = @consumer.get_request_token
+    #
+    # To include OAuth parameters:
+    #
+    #  @request_token = @consumer.get_request_token \
+    #    :oauth_callback => "http://example.com/cb"
+    #
+    # To include application-specific parameters:
+    #
+    #  @request_token = @consumer.get_request_token({}, :foo => "bar")
+    #
+    # TODO oauth_callback should be a mandatory parameter
+    def get_request_token(request_options = {}, *arguments, &block)
+      # if oauth_callback wasn't provided, it is assumed that oauth_verifiers
+      # will be exchanged out of band
+      request_options[:oauth_callback] ||= OAuth::OUT_OF_BAND unless request_options[:exclude_callback]
+
+      if block_given?
+        response = token_request(http_method,
+        (request_token_url? ? request_token_url : request_token_path),
+        nil,
+        request_options,
+        *arguments, &block)
+      else
+        response = token_request(http_method, (request_token_url? ? request_token_url : request_token_path), nil, request_options, *arguments)
+      end
+      OAuth::RequestToken.from_hash(self, response)
+    end
+
+    # Creates, signs and performs an http request.
+    # It's recommended to use the OAuth::Token classes to set this up correctly.
+    # request_options take precedence over consumer-wide options when signing
+    #   a request.
+    # arguments are POST and PUT bodies (a Hash, string-encoded parameters, or
+    #   absent), followed by additional HTTP headers.
+    #
+    #   @consumer.request(:get,  '/people', @token, { :scheme => :query_string })
+    #   @consumer.request(:post, '/people', @token, {}, @person.to_xml, { 'Content-Type' => 'application/xml' })
+    #
+    def request(http_method, path, token = nil, request_options = {}, *arguments)
+      if path !~ /^\//
+        @http = create_http(path)
+        _uri = URI.parse(path)
+        path = "#{_uri.path}#{_uri.query ? "?#{_uri.query}" : ""}"
+      end
+
+      # override the request with your own, this is useful for file uploads which Net::HTTP does not do
+      req = create_signed_request(http_method, path, token, request_options, *arguments)
+      return nil if block_given? and yield(req) == :done
+      rsp = http.request(req)
+      # check for an error reported by the Problem Reporting extension
+      # (http://wiki.oauth.net/ProblemReporting)
+      # note: a 200 may actually be an error; check for an oauth_problem key to be sure
+      if !(headers = rsp.to_hash["www-authenticate"]).nil? &&
+        (h = headers.select { |hdr| hdr =~ /^OAuth / }).any? &&
+        h.first =~ /oauth_problem/
+
+        # puts "Header: #{h.first}"
+
+        # TODO doesn't handle broken responses from api.login.yahoo.com
+        # remove debug code when done
+        params = OAuth::Helper.parse_header(h.first)
+
+        # puts "Params: #{params.inspect}"
+        # puts "Body: #{rsp.body}"
+
+        raise OAuth::Problem.new(params.delete("oauth_problem"), rsp, params)
+      end
+
+      rsp
+    end
+
+    # Creates and signs an http request.
+    # It's recommended to use the Token classes to set this up correctly
+    def create_signed_request(http_method, path, token = nil, request_options = {}, *arguments)
+      request = create_http_request(http_method, path, *arguments)
+      sign!(request, token, request_options)
+      request
+    end
+
+    # Creates a request and parses the result as url_encoded. This is used internally for the RequestToken and AccessToken requests.
+    def token_request(http_method, path, token = nil, request_options = {}, *arguments)
+      response = request(http_method, path, token, request_options, *arguments)
+      case response.code.to_i
+
+      when (200..299)
+        if block_given?
+          yield response.body
+        else
+          # symbolize keys
+          # TODO this could be considered unexpected behavior; symbols or not?
+          # TODO this also drops subsequent values from multi-valued keys
+          CGI.parse(response.body).inject({}) do |h,(k,v)|
+            h[k.strip.to_sym] = v.first
+            h[k.strip]        = v.first
+            h
+          end
+        end
+      when (300..399)
+        # this is a redirect
+        uri = URI.parse(response.header['location'])
+        response.error! if uri.path == path # careful of those infinite redirects
+        self.token_request(http_method, uri.path, token, request_options, arguments)
+      when (400..499)
+        raise OAuth::Unauthorized, response
+      else
+        response.error!
+      end
+    end
+
+    # Sign the Request object. Use this if you have an externally generated http request object you want to sign.
+    def sign!(request, token = nil, request_options = {})
+      request.oauth!(http, self, token, options.merge(request_options))
+    end
+
+    # Return the signature_base_string
+    def signature_base_string(request, token = nil, request_options = {})
+      request.signature_base_string(http, self, token, options.merge(request_options))
+    end
+
+    def site
+      @options[:site].to_s
+    end
+
+    def request_endpoint
+  return nil if @options[:request_endpoint].nil?
+  @options[:request_endpoint].to_s
+    end
+
+    def scheme
+      @options[:scheme]
+    end
+
+    def request_token_path
+      @options[:request_token_path]
+    end
+
+    def authorize_path
+      @options[:authorize_path]
+    end
+
+    def access_token_path
+      @options[:access_token_path]
+    end
+
+    # TODO this is ugly, rewrite
+    def request_token_url
+      @options[:request_token_url] || site + request_token_path
+    end
+
+    def request_token_url?
+      @options.has_key?(:request_token_url)
+    end
+
+    def authorize_url
+      @options[:authorize_url] || site + authorize_path
+    end
+
+    def authorize_url?
+      @options.has_key?(:authorize_url)
+    end
+
+    def access_token_url
+      @options[:access_token_url] || site + access_token_path
+    end
+
+    def access_token_url?
+      @options.has_key?(:access_token_url)
+    end
+
+    def proxy
+      @options[:proxy]
+    end
+
+    protected
+
+    # Instantiates the http object
+    def create_http(_url = nil)
+
+
+      if !request_endpoint.nil?
+       _url = request_endpoint
+      end
+
+
+      if _url.nil? || _url[0] =~ /^\//
+        our_uri = URI.parse(site)
+      else
+        our_uri = URI.parse(_url)
+      end
+
+
+      if proxy.nil?
+        http_object = Net::HTTP.new(our_uri.host, our_uri.port)
+      else
+        proxy_uri = proxy.is_a?(URI) ? proxy : URI.parse(proxy)
+        http_object = Net::HTTP.new(our_uri.host, our_uri.port, proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+      end
+
+      http_object.use_ssl = (our_uri.scheme == 'https')
+
+      if @options[:ca_file] || CA_FILE
+        http_object.ca_file = @options[:ca_file] || CA_FILE
+        http_object.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http_object.verify_depth = 5
+      else
+        http_object.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      http_object.read_timeout = http_object.open_timeout = @options[:timeout] || 30
+      http_object.open_timeout = @options[:open_timeout] if @options[:open_timeout]
+
+      http_object
+    end
+
+    # create the http request object for a given http_method and path
+    def create_http_request(http_method, path, *arguments)
+      http_method = http_method.to_sym
+
+      if [:post, :put].include?(http_method)
+        data = arguments.shift
+      end
+
+      # if the base site contains a path, add it now
+      uri = URI.parse(site)
+      path = uri.path + path if uri.path && uri.path != '/'
+
+      headers = arguments.first.is_a?(Hash) ? arguments.shift : {}
+
+      case http_method
+      when :post
+        request = Net::HTTP::Post.new(path,headers)
+        request["Content-Length"] = '0' # Default to 0
+      when :put
+        request = Net::HTTP::Put.new(path,headers)
+        request["Content-Length"] = '0' # Default to 0
+      when :get
+        request = Net::HTTP::Get.new(path,headers)
+      when :delete
+        request =  Net::HTTP::Delete.new(path,headers)
+      when :head
+        request = Net::HTTP::Head.new(path,headers)
+      else
+        raise ArgumentError, "Don't know how to handle http_method: :#{http_method.to_s}"
+      end
+
+      if data.is_a?(Hash)
+        request.body = OAuth::Helper.normalize(data)
+        request.content_type = 'application/x-www-form-urlencoded'
+      elsif data
+        if data.respond_to?(:read)
+          request.body_stream = data
+          if data.respond_to?(:length)
+            request["Content-Length"] = data.length.to_s
+          elsif data.respond_to?(:stat) && data.stat.respond_to?(:size)
+            request["Content-Length"] = data.stat.size.to_s
+          else
+            raise ArgumentError, "Don't know how to send a body_stream that doesn't respond to .length or .stat.size"
+          end
+        else
+          request.body = data.to_s
+          request["Content-Length"] = request.body.length.to_s
+        end
+      end
+
+      request
+    end
+
+    def marshal_dump(*args)
+      {:key => @key, :secret => @secret, :options => @options}
+    end
+
+    def marshal_load(data)
+      initialize(data[:key], data[:secret], data[:options])
+    end
+
+  end
+end