oauth-ap 0.4.8

data/lib/oauth/request_proxy/curb_request.rb

@@ -0,0 +1,55 @@
+  require 'oauth/request_proxy/base'
+require 'curb'
+require 'uri'
+require 'cgi'
+
+module OAuth::RequestProxy::Curl
+  class Easy < OAuth::RequestProxy::Base
+    # Proxy for signing Curl::Easy requests
+    # Usage example:
+    # oauth_params = {:consumer => oauth_consumer, :token => access_token}
+    # req = Curl::Easy.new(uri)
+    # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
+    # req.headers.merge!({"Authorization" => oauth_helper.header})
+    # req.http_get
+    # response = req.body_str
+    proxies ::Curl::Easy
+
+    def method
+      nil
+    end
+
+    def uri
+      options[:uri].to_s
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters]
+      else
+        post_parameters.merge(query_parameters).merge(options[:parameters] || {})
+      end
+    end
+
+    private
+
+    def query_parameters
+      query = URI.parse(request.url).query
+      return(query ? CGI.parse(query) : {})
+    end
+
+    def post_parameters
+      post_body = {}
+
+      # Post params are only used if posting form data
+      if (request.headers['Content-Type'] && request.headers['Content-Type'].to_s.downcase.start_with?("application/x-www-form-urlencoded"))
+
+        request.post_body.split("&").each do |str|
+          param = str.split("=")
+          post_body[param[0]] = param[1]
+        end
+      end
+      post_body
+    end
+  end
+end

data/lib/oauth/request_proxy/em_http_request.rb

@@ -0,0 +1,66 @@
+require 'oauth/request_proxy/base'
+# em-http also uses adddressable so there is no need to require uri.
+require 'em-http'
+require 'cgi'
+
+module OAuth::RequestProxy::EventMachine
+  class HttpRequest < OAuth::RequestProxy::Base
+
+    # A Proxy for use when you need to sign EventMachine::HttpClient instances.
+    # It needs to be called once the client is construct but before data is sent.
+    # Also see oauth/client/em-http
+    proxies ::EventMachine::HttpClient
+
+    # Request in this con
+
+    def method
+      request.method
+    end
+
+    def uri
+      request.normalize_uri.to_s
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters]
+      else
+        all_parameters
+      end
+    end
+
+    protected
+
+    def all_parameters
+      merged_parameters({}, post_parameters, query_parameters, options[:parameters])
+    end
+
+    def query_parameters
+      CGI.parse(request.normalize_uri.query.to_s)
+    end
+
+    def post_parameters
+      headers = request.options[:head] || {}
+      form_encoded = headers['Content-Type'].to_s.downcase.start_with?("application/x-www-form-urlencoded")
+      if ['POST', 'PUT'].include?(method) && form_encoded
+        CGI.parse(request.normalize_body.to_s)
+      else
+        {}
+      end
+    end
+
+    def merged_parameters(params, *extra_params)
+      extra_params.compact.each do |params_pairs|
+        params_pairs.each_pair do |key, value|
+          if params.has_key?(key)
+            params[key] += value
+          else
+            params[key] = [value].flatten
+          end
+        end
+      end
+      params
+    end
+
+  end
+end

data/lib/oauth/request_proxy/jabber_request.rb

@@ -0,0 +1,41 @@
+require 'xmpp4r'
+require 'oauth/request_proxy/base'
+
+module OAuth
+  module RequestProxy
+    class JabberRequest < OAuth::RequestProxy::Base
+      proxies Jabber::Iq
+      proxies Jabber::Presence
+      proxies Jabber::Message
+
+      def parameters
+        return @params if @params
+
+        @params = {}
+
+        oauth = @request.get_elements('//oauth').first
+        return @params unless oauth
+
+        %w( oauth_token oauth_consumer_key oauth_signature_method oauth_signature
+            oauth_timestamp oauth_nonce oauth_version ).each do |param|
+          next unless element = oauth.first_element(param)
+          @params[param] = element.text
+        end
+
+        @params
+      end
+
+      def method
+        @request.name
+      end
+
+      def uri
+        [@request.from.strip.to_s, @request.to.strip.to_s].join("&")
+      end
+
+      def normalized_uri
+        uri
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/mock_request.rb

@@ -0,0 +1,44 @@
+require 'oauth/request_proxy/base'
+
+module OAuth
+  module RequestProxy
+    # RequestProxy for Hashes to facilitate simpler signature creation.
+    # Usage:
+    #   request = OAuth::RequestProxy.proxy \
+    #      "method" => "iq",
+    #      "uri"    => [from, to] * "&",
+    #      "parameters" => {
+    #        "oauth_consumer_key"     => oauth_consumer_key,
+    #        "oauth_token"            => oauth_token,
+    #        "oauth_signature_method" => "HMAC-SHA1"
+    #      }
+    #
+    #   signature = OAuth::Signature.sign \
+    #     request,
+    #     :consumer_secret => oauth_consumer_secret,
+    #     :token_secret    => oauth_token_secret,
+    class MockRequest < OAuth::RequestProxy::Base
+      proxies Hash
+
+      def parameters
+        @request["parameters"]
+      end
+
+      def method
+        @request["method"]
+      end
+
+      def normalized_uri
+        super
+      rescue
+        # if this is a non-standard URI, it may not parse properly
+        # in that case, assume that it's already been normalized
+        uri
+      end
+
+      def uri
+        @request["uri"]
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/net_http.rb

@@ -0,0 +1,73 @@
+require 'oauth/request_proxy/base'
+require 'net/http'
+require 'uri'
+require 'cgi'
+
+module OAuth::RequestProxy::Net
+  module HTTP
+    class HTTPRequest < OAuth::RequestProxy::Base
+      proxies ::Net::HTTPGenericRequest
+
+      def method
+        request.method
+      end
+
+      def uri
+        options[:uri].to_s
+      end
+
+      def parameters
+        if options[:clobber_request]
+          options[:parameters]
+        else
+          all_parameters
+        end
+      end
+
+      def body
+        request.body
+      end
+
+    private
+
+      def all_parameters
+        request_params = CGI.parse(query_string)
+        # request_params.each{|k,v| request_params[k] = [nil] if v == []}
+
+        if options[:parameters]
+          options[:parameters].each do |k,v|
+            if request_params.has_key?(k) && v
+              request_params[k] << v
+            else
+              request_params[k] = [v]
+            end
+          end
+        end
+        request_params
+      end
+
+      def query_string
+        params = [ query_params, auth_header_params ]
+        params << post_params if (method.to_s.upcase == 'POST' || method.to_s.upcase == 'PUT') && form_url_encoded?
+        params.compact.join('&')
+      end
+
+      def form_url_encoded?
+        request['Content-Type'] != nil && request['Content-Type'].to_s.downcase.start_with?('application/x-www-form-urlencoded')
+      end
+
+      def query_params
+        URI.parse(request.path).query
+      end
+
+      def post_params
+        request.body
+      end
+
+      def auth_header_params
+        return nil unless request['Authorization'] && request['Authorization'][0,5] == 'OAuth'
+        auth_params = request['Authorization']
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/rack_request.rb

@@ -0,0 +1,44 @@
+require 'oauth/request_proxy/base'
+require 'uri'
+require 'rack'
+
+module OAuth::RequestProxy
+  class RackRequest < OAuth::RequestProxy::Base
+    proxies Rack::Request
+
+    def method
+      request.env["rack.methodoverride.original_method"] || request.request_method
+    end
+
+    def uri
+      request.url
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters] || {}
+      else
+        params = request_params.merge(query_params).merge(header_params)
+        params.merge(options[:parameters] || {})
+      end
+    end
+
+    def signature
+      parameters['oauth_signature']
+    end
+
+  protected
+
+    def query_params
+      request.GET
+    end
+
+    def request_params
+      if request.content_type and request.content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
+        request.POST
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/oauth/request_proxy/rest_client_request.rb

@@ -0,0 +1,67 @@
+require 'oauth/request_proxy/base'
+require 'rest-client'
+require 'restclient/request'
+require 'uri'
+require 'cgi'
+
+module OAuth::RequestProxy::RestClient
+  class Request < OAuth::RequestProxy::Base
+    proxies RestClient::Request
+    
+      def method
+        request.method.to_s.upcase
+      end
+
+      def uri
+        request.url
+      end
+
+      def parameters
+        if options[:clobber_request]
+          options[:parameters] || {}
+        else
+          post_parameters.merge(query_params).merge(options[:parameters] || {})
+        end
+      end
+
+      def body
+        request.payload.to_s
+      end
+
+    protected
+
+      def query_params
+        query = URI.parse(request.url).query
+        query ? CGI.parse(query) : {}
+      end
+
+      def request_params
+      end
+      
+      def post_parameters
+        # Post params are only used if posting form data
+        if method == 'POST' || method == 'PUT'
+          OAuth::Helper.stringify_keys(query_string_to_hash(request.payload.to_s) || {})
+        else
+          {}
+        end
+      end
+      
+   private
+      
+      def query_string_to_hash(query)
+        keyvals = query.split('&').inject({}) do |result, q| 
+          k,v = q.split('=')
+          if !v.nil?
+             result.merge({k => v})
+          elsif !result.key?(k)
+            result.merge({k => true})
+          else
+            result
+          end
+        end
+        keyvals
+      end
+      
+  end
+end

data/lib/oauth/request_proxy/typhoeus_request.rb

@@ -0,0 +1,53 @@
+require 'oauth/request_proxy/base'
+require 'typhoeus'
+require 'typhoeus/request'
+require 'uri'
+require 'cgi'
+
+module OAuth::RequestProxy::Typhoeus
+  class Request < OAuth::RequestProxy::Base
+    # Proxy for signing Typhoeus::Request requests
+    # Usage example:
+    # oauth_params = {:consumer => oauth_consumer, :token => access_token}
+    # req = Typhoeus::Request.new(uri, options)
+    # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
+    # req.headers.merge!({"Authorization" => oauth_helper.header})
+    # hydra = Typhoeus::Hydra.new()
+    # hydra.queue(req)
+    # hydra.run
+    # response = req.response
+    proxies Typhoeus::Request
+
+    def method
+      request.method.to_s.upcase
+    end
+
+    def uri
+      options[:uri].to_s
+    end
+
+    def parameters
+      if options[:clobber_request]
+        options[:parameters]
+      else
+        post_parameters.merge(query_parameters).merge(options[:parameters] || {})
+      end
+    end
+
+    private
+
+    def query_parameters
+      query = URI.parse(request.url).query
+      query ? CGI.parse(query) : {}
+    end
+
+    def post_parameters
+      # Post params are only used if posting form data
+      if method == 'POST'
+        OAuth::Helper.stringify_keys(request.params || {})
+      else
+        {}
+      end
+    end
+  end
+end