oauth 0.5.6 → 1.1.0

data/lib/oauth/request_proxy/em_http_request.rb

@@ -1,66 +1,76 @@
-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
+# frozen_string_literal: true
 
-    # 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
+require "oauth/request_proxy/base"
+# em-http also uses adddressable so there is no need to require uri.
+require "em-http"
+require "cgi"
 
-    # Request in this con
+module OAuth
+  module RequestProxy
+    module 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
 
-    def method
-      request.method
-    end
+        # Request in this con
 
-    def uri
-      request.normalize_uri.to_s
-    end
+        def method
+          request.req[:method]
+        end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters]
-      else
-        all_parameters
-      end
-    end
+        def uri
+          request.conn.normalize.to_s
+        end
 
-    protected
+        def parameters
+          if options[:clobber_request]
+            options[:parameters]
+          else
+            all_parameters
+          end
+        end
 
-    def all_parameters
-      merged_parameters({}, post_parameters, query_parameters, options[:parameters])
-    end
+        protected
 
-    def query_parameters
-      CGI.parse(request.normalize_uri.query.to_s)
-    end
+        def all_parameters
+          merged_parameters({}, post_parameters, query_parameters, options[:parameters])
+        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 query_parameters
+          quer = request.req[:query]
+          hash_quer = if quer.respond_to?(:merge)
+                        quer
+                      else
+                        CGI.parse(quer.to_s)
+                      end
+          CGI.parse(request.conn.query.to_s).merge(hash_quer)
+        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
+        def post_parameters
+          headers = request.req[:head] || {}
+          form_encoded = headers["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
+          if %w[POST PUT].include?(method) && form_encoded
+            CGI.parse(request.normalize_body(request.req[:body]).to_s)
           else
-            params[key] = [value].flatten
+            {}
           end
         end
+
+        def merged_parameters(params, *extra_params)
+          extra_params.compact.each do |params_pairs|
+            params_pairs.each_pair do |key, value|
+              if params.key?(key)
+                params[key.to_s] += value
+              else
+                params[key.to_s] = [value].flatten
+              end
+            end
+          end
+          params
+        end
       end
-      params
     end
-
   end
 end

data/lib/oauth/request_proxy/jabber_request.rb

@@ -1,24 +1,27 @@
-require 'xmpp4r'
-require 'oauth/request_proxy/base'
+# frozen_string_literal: true
+
+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
+      proxies ::Jabber::Iq
+      proxies ::Jabber::Presence
+      proxies ::Jabber::Message
 
       def parameters
         return @params if @params
 
         @params = {}
 
-        oauth = @request.get_elements('//oauth').first
+        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)
+        %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
 

data/lib/oauth/request_proxy/mock_request.rb

@@ -1,4 +1,6 @@
-require 'oauth/request_proxy/base'
+# frozen_string_literal: true
+
+require "oauth/request_proxy/base"
 
 module OAuth
   module RequestProxy
@@ -18,7 +20,7 @@ module OAuth
     #     :consumer_secret => oauth_consumer_secret,
     #     :token_secret    => oauth_token_secret,
     class MockRequest < OAuth::RequestProxy::Base
-      proxies Hash
+      proxies ::Hash
 
       def parameters
         @request["parameters"]
@@ -30,7 +32,7 @@ module OAuth
 
       def normalized_uri
         super
-      rescue
+      rescue StandardError
         # if this is a non-standard URI, it may not parse properly
         # in that case, assume that it's already been normalized
         uri

data/lib/oauth/request_proxy/net_http.rb

@@ -1,72 +1,79 @@
-require 'oauth/request_proxy/base'
-require 'net/http'
-require 'uri'
-require 'cgi'
+# frozen_string_literal: true
 
-module OAuth::RequestProxy::Net
-  module HTTP
-    class HTTPRequest < OAuth::RequestProxy::Base
-      proxies ::Net::HTTPGenericRequest
+require "oauth/request_proxy/base"
+require "net/http"
+require "uri"
+require "cgi"
 
-      def method
-        request.method
-      end
+module OAuth
+  module RequestProxy
+    module Net
+      module HTTP
+        class HTTPRequest < OAuth::RequestProxy::Base
+          proxies ::Net::HTTPGenericRequest
 
-      def uri
-        options[:uri].to_s
-      end
+          def method
+            request.method
+          end
 
-      def parameters
-        if options[:clobber_request]
-          options[:parameters]
-        else
-          all_parameters
-        end
-      end
+          def uri
+            options[:uri].to_s
+          end
 
-      def body
-        request.body
-      end
+          def parameters
+            if options[:clobber_request]
+              options[:parameters]
+            else
+              all_parameters
+            end
+          end
 
-    private
+          def body
+            request.body
+          end
 
-      def all_parameters
-        request_params = CGI.parse(query_string)
-        # request_params.each{|k,v| request_params[k] = [nil] if v == []}
+          private
 
-        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]
+          def all_parameters
+            request_params = CGI.parse(query_string)
+            # request_params.each{|k,v| request_params[k] = [nil] if v == []}
+
+            options[:parameters]&.each do |k, v|
+              if request_params.key?(k) && v
+                request_params[k] << v
+              else
+                request_params[k] = [v]
+              end
             end
+            request_params
           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 query_string
+            params = [query_params, auth_header_params]
+            if (method.to_s.casecmp("POST").zero? || method.to_s.casecmp("PUT").zero?) && form_url_encoded?
+              params << post_params
+            end
+            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 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 query_params
+            URI.parse(request.path).query
+          end
 
-      def post_params
-        request.body
-      end
+          def post_params
+            request.body
+          end
 
-      def auth_header_params
-        return nil unless request['Authorization'] && request['Authorization'][0,5] == 'OAuth'
-        request['Authorization']
+          def auth_header_params
+            return nil unless request["Authorization"] && request["Authorization"][0, 5] == "OAuth"
+
+            request["Authorization"]
+          end
+        end
       end
     end
   end

data/lib/oauth/request_proxy/rack_request.rb

@@ -1,43 +1,47 @@
-require 'oauth/request_proxy/base'
-require 'uri'
-require 'rack'
+# frozen_string_literal: true
 
-module OAuth::RequestProxy
-  class RackRequest < OAuth::RequestProxy::Base
-    proxies Rack::Request
+require "oauth/request_proxy/base"
+require "uri"
+require "rack"
 
-    def method
-      request.env["rack.methodoverride.original_method"] || request.request_method
-    end
+module OAuth
+  module RequestProxy
+    class RackRequest < OAuth::RequestProxy::Base
+      proxies ::Rack::Request
 
-    def uri
-      request.url
-    end
+      def method
+        request.env["rack.methodoverride.original_method"] || request.request_method
+      end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters] || {}
-      else
-        params = request_params.merge(query_params).merge(header_params)
-        params.merge(options[:parameters] || {})
+      def uri
+        request.url
       end
-    end
 
-    def signature
-      parameters['oauth_signature']
-    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
 
-  protected
+      def signature
+        parameters["oauth_signature"]
+      end
 
-    def query_params
-      request.GET
-    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
-        {}
+      def request_params
+        if request.content_type && 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

@@ -1,62 +1,66 @@
-require 'oauth/request_proxy/base'
-require 'rest-client'
-require 'uri'
-require 'cgi'
-
-module OAuth::RequestProxy::RestClient
-  class Request < OAuth::RequestProxy::Base
-    proxies RestClient::Request
-    
-      def method
-        request.method.to_s.upcase
-      end
+# frozen_string_literal: true
 
-      def uri
-        request.url
-      end
+require "oauth/request_proxy/base"
+require "rest-client"
+require "uri"
+require "cgi"
+
+module OAuth
+  module RequestProxy
+    module RestClient
+      class Request < OAuth::RequestProxy::Base
+        proxies ::RestClient::Request
 
-      def parameters
-        if options[:clobber_request]
-          options[:parameters] || {}
-        else
-          post_parameters.merge(query_params).merge(options[:parameters] || {})
+        def method
+          request.method.to_s.upcase
         end
-      end
 
-    protected
+        def uri
+          request.url
+        end
 
-      def query_params
-        query = URI.parse(request.url).query
-        query ? CGI.parse(query) : {}
-      end
+        def parameters
+          if options[:clobber_request]
+            options[:parameters] || {}
+          else
+            post_parameters.merge(query_params).merge(options[:parameters] || {})
+          end
+        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
-          {}
+        protected
+
+        def query_params
+          query = URI.parse(request.url).query
+          query ? CGI.parse(query) : {}
         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})
+
+        def request_params; end
+
+        def post_parameters
+          # Post params are only used if posting form data
+          is_form_data = request.payload && request.payload.headers["Content-Type"] == "application/x-www-form-urlencoded"
+          if is_form_data && (method == "POST" || method == "PUT")
+            OAuth::Helper.stringify_keys(query_string_to_hash(request.payload.to_s) || {})
           else
-            result
+            {}
+          end
+        end
+
+        private
+
+        def query_string_to_hash(query)
+          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
         end
-        keyvals
       end
-      
+    end
   end
-end
+end

data/lib/oauth/request_proxy/typhoeus_request.rb

@@ -1,53 +1,59 @@
-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.options[: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 = request.options[:method].to_s.upcase
-      request_method.empty? ? 'GET' : request_method
-    end
+# frozen_string_literal: true
 
-    def uri
-      options[:uri].to_s
-    end
+require "oauth/request_proxy/base"
+require "typhoeus"
+require "typhoeus/request"
+require "uri"
+require "cgi"
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters]
-      else
-        post_parameters.merge(query_parameters).merge(options[:parameters] || {})
-      end
-    end
+module OAuth
+  module RequestProxy
+    module 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.options[:headers].merge!({"Authorization" => oauth_helper.header})
+        # hydra = Typhoeus::Hydra.new()
+        # hydra.queue(req)
+        # hydra.run
+        # response = req.response
+        proxies ::Typhoeus::Request
 
-    private
+        def method
+          request_method = request.options[:method].to_s.upcase
+          request_method.empty? ? "GET" : request_method
+        end
 
-    def query_parameters
-      query = URI.parse(request.url).query
-      query ? CGI.parse(query) : {}
-    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.options[:params] || {})
-      else
-        {}
+        def post_parameters
+          # Post params are only used if posting form data
+          if method == "POST"
+            OAuth::Helper.stringify_keys(request.options[:params] || {})
+          else
+            {}
+          end
+        end
       end
     end
   end

data/lib/oauth/request_proxy.rb

@@ -1,24 +1,27 @@
+# frozen_string_literal: true
+
 module OAuth
   module RequestProxy
-    def self.available_proxies #:nodoc:
+    def self.available_proxies # :nodoc:
       @available_proxies ||= {}
     end
 
     def self.proxy(request, options = {})
-      return request if request.kind_of?(OAuth::RequestProxy::Base)
+      return request if request.is_a?(OAuth::RequestProxy::Base)
 
       klass = available_proxies[request.class]
 
       # Search for possible superclass matches.
       if klass.nil?
-        request_parent = available_proxies.keys.find { |rc| request.kind_of?(rc) }
+        request_parent = available_proxies.keys.find { |rc| request.is_a?(rc) }
         klass = available_proxies[request_parent]
       end
 
       raise UnknownRequestType, request.class.to_s unless klass
+
       klass.new(request, options)
     end
 
-    class UnknownRequestType < Exception; end
+    class UnknownRequestType < RuntimeError; end
   end
 end