oauth 0.5.6 → 1.1.5

data/lib/oauth/request_proxy/base.rb

@@ -1,178 +1,193 @@
-require 'oauth/request_proxy'
-require 'oauth/helper'
+# frozen_string_literal: true
 
-module OAuth::RequestProxy
-  class Base
-    include OAuth::Helper
+require "oauth/request_proxy"
+require "oauth/helper"
 
-    def self.proxies(klass)
-      OAuth::RequestProxy.available_proxies[klass] = self
-    end
+module OAuth
+  module RequestProxy
+    class Base
+      include OAuth::Helper
 
-    attr_accessor :request, :options, :unsigned_parameters
+      class << self
+        def proxies(klass)
+          OAuth::RequestProxy.available_proxies[klass] = self
+        end
+      end
 
-    def initialize(request, options = {})
-      @request = request
-      @unsigned_parameters = (options[:unsigned_parameters] || []).map {|param| param.to_s}
-      @options = options
-    end
+      attr_accessor :request, :options, :unsigned_parameters
 
-    ## OAuth parameters
+      def initialize(request, options = {})
+        @request = request
+        @unsigned_parameters = (options[:unsigned_parameters] || []).map(&:to_s)
+        @options = options
+      end
 
-    def oauth_callback
-      parameters['oauth_callback']
-    end
+      ## OAuth parameters
 
-    def oauth_consumer_key
-      parameters['oauth_consumer_key']
-    end
+      def oauth_callback
+        [parameters["oauth_callback"]].flatten.first
+      end
 
-    def oauth_nonce
-      parameters['oauth_nonce']
-    end
+      def oauth_consumer_key
+        [parameters["oauth_consumer_key"]].flatten.first
+      end
 
-    def oauth_signature
-      # TODO can this be nil?
-      [parameters['oauth_signature']].flatten.first || ""
-    end
+      def oauth_nonce
+        [parameters["oauth_nonce"]].flatten.first
+      end
 
-    def oauth_signature_method
-      case parameters['oauth_signature_method']
-      when Array
-        parameters['oauth_signature_method'].first
-      else
-        parameters['oauth_signature_method']
+      def oauth_signature
+        # TODO: can this be nil?
+        [parameters["oauth_signature"]].flatten.first || ""
       end
-    end
 
-    def oauth_timestamp
-      parameters['oauth_timestamp']
-    end
+      def oauth_signature_method
+        [parameters["oauth_signature_method"]].flatten.first
+      end
 
-    def oauth_token
-      parameters['oauth_token']
-    end
+      def oauth_timestamp
+        [parameters["oauth_timestamp"]].flatten.first
+      end
 
-    def oauth_verifier
-      parameters['oauth_verifier']
-    end
+      def oauth_token
+        [parameters["oauth_token"]].flatten.first
+      end
 
-    def oauth_version
-      parameters["oauth_version"]
-    end
+      # OAuth 1.0a only: value returned to the Consumer after user authorization
+      # and required when exchanging a Request Token for an Access Token.
+      # Not present in OAuth 1.0 flows.
+      def oauth_verifier
+        [parameters["oauth_verifier"]].flatten.first
+      end
 
-    # TODO deprecate these
-    alias_method :consumer_key,     :oauth_consumer_key
-    alias_method :token,            :oauth_token
-    alias_method :nonce,            :oauth_nonce
-    alias_method :timestamp,        :oauth_timestamp
-    alias_method :signature,        :oauth_signature
-    alias_method :signature_method, :oauth_signature_method
+      def oauth_version
+        [parameters["oauth_version"]].flatten.first
+      end
 
-    ## Parameter accessors
+      # TODO: deprecate these
+      alias_method :consumer_key, :oauth_consumer_key
+      alias_method :token, :oauth_token
+      alias_method :nonce, :oauth_nonce
+      alias_method :timestamp, :oauth_timestamp
+      alias_method :signature, :oauth_signature
+      alias_method :signature_method, :oauth_signature_method
 
-    def parameters
-      raise NotImplementedError, "Must be implemented by subclasses"
-    end
+      ## Parameter accessors
 
-    def parameters_for_signature
-      parameters.select { |k,v| not signature_and_unsigned_parameters.include?(k) }
-    end
+      def parameters
+        raise NotImplementedError, "Must be implemented by subclasses"
+      end
 
-    def oauth_parameters
-      parameters.select { |k,v| OAuth::PARAMETERS.include?(k) }.reject { |k,v| v == "" }
-    end
+      def parameters_for_signature
+        parameters.select { |k, _v| !signature_and_unsigned_parameters.include?(k) }
+      end
 
-    def non_oauth_parameters
-      parameters.reject { |k,v| OAuth::PARAMETERS.include?(k) }
-    end
+      def oauth_parameters
+        parameters.select { |k, v| OAuth::PARAMETERS.include?(k) && !v.nil? && v != "" }
+      end
 
-    def signature_and_unsigned_parameters
-      unsigned_parameters+["oauth_signature"]
-    end
+      def non_oauth_parameters
+        parameters.select { |k, _v| !OAuth::PARAMETERS.include?(k) }
+      end
 
-    # See 9.1.2 in specs
-    def normalized_uri
-      u = URI.parse(uri)
-      "#{u.scheme.downcase}://#{u.host.downcase}#{(u.scheme.downcase == 'http' && u.port != 80) || (u.scheme.downcase == 'https' && u.port != 443) ? ":#{u.port}" : ""}#{(u.path && u.path != '') ? u.path : '/'}"
-    end
+      def signature_and_unsigned_parameters
+        unsigned_parameters + ["oauth_signature"]
+      end
 
-    # See 9.1.1. in specs Normalize Request Parameters
-    def normalized_parameters
-      normalize(parameters_for_signature)
-    end
+      # See 9.1.2 in specs
+      def normalized_uri
+        u = URI.parse(uri)
+        "#{u.scheme.downcase}://#{u.host.downcase}#{":#{u.port}" if (u.scheme.casecmp("http").zero? && u.port != 80) || (u.scheme.casecmp("https").zero? && u.port != 443)}#{(u.path && u.path != "") ? u.path : "/"}"
+      end
 
-    def sign(options = {})
-      OAuth::Signature.sign(self, options)
-    end
+      # See 9.1.1. in specs Normalize Request Parameters
+      def normalized_parameters
+        normalize(parameters_for_signature)
+      end
 
-    def sign!(options = {})
-      parameters["oauth_signature"] = sign(options)
-      @signed = true
-      signature
-    end
+      def sign(options = {})
+        OAuth::Signature.sign(self, options)
+      end
 
-    # See 9.1 in specs
-    def signature_base_string
-      base = [method, normalized_uri, normalized_parameters]
-      base.map { |v| escape(v) }.join("&")
-    end
+      def sign!(options = {})
+        parameters["oauth_signature"] = sign(options)
+        @signed = true
+        signature
+      end
 
-    # Has this request been signed yet?
-    def signed?
-      @signed
-    end
+      # See 9.1 in specs
+      def signature_base_string
+        base = [method, normalized_uri, normalized_parameters]
+        base.map { |v| escape(v) }.join("&")
+      end
 
-    # URI, including OAuth parameters
-    def signed_uri(with_oauth = true)
-      if signed?
-        if with_oauth
-          params = parameters
+      # Has this request been signed yet?
+      def signed?
+        @signed
+      end
+
+      # URI, including OAuth parameters
+      def signed_uri(with_oauth: true)
+        if signed?
+          params = if with_oauth
+            parameters
+          else
+            non_oauth_parameters
+          end
+
+          [uri, normalize(params)].join("?")
         else
-          params = non_oauth_parameters
+          warn("This request has not yet been signed!")
         end
-
-        [uri, normalize(params)] * "?"
-      else
-        STDERR.puts "This request has not yet been signed!"
       end
-    end
 
-    # Authorization header for OAuth
-    def oauth_header(options = {})
-      header_params_str = oauth_parameters.map { |k,v| "#{k}=\"#{escape(v)}\"" }.join(', ')
+      # Authorization header for OAuth
+      def oauth_header(options = {})
+        header_params_str = oauth_parameters.map { |k, v| "#{k}=\"#{escape(v)}\"" }.join(", ")
 
-      realm = "realm=\"#{options[:realm]}\", " if options[:realm]
-      "OAuth #{realm}#{header_params_str}"
-    end
+        realm = "realm=\"#{options[:realm]}\", " if options[:realm]
+        "OAuth #{realm}#{header_params_str}"
+      end
 
-    def query_string_blank?
-      if uri = request.env['REQUEST_URI']
-        uri.split('?', 2)[1].nil?
-      else
-        request.query_string.match(/\A\s*\z/)
+      def query_string_blank?
+        if (uri = request.env["REQUEST_URI"])
+          uri.split("?", 2)[1].nil?
+        else
+          request.query_string.match(/\A\s*\z/)
+        end
       end
-    end
 
-  protected
+      protected
 
-    def header_params
-      %w( X-HTTP_AUTHORIZATION Authorization HTTP_AUTHORIZATION ).each do |header|
-        next unless request.env.include?(header)
+      def header_params
+        %w[X-HTTP_AUTHORIZATION Authorization HTTP_AUTHORIZATION].each do |header|
+          next unless request.env.include?(header)
 
-        header = request.env[header]
-        next unless header[0,6] == 'OAuth '
+          header = request.env[header]
+          next unless header[0, 6] == "OAuth "
 
-        # parse the header into a Hash
-        oauth_params = OAuth::Helper.parse_header(header)
+          # parse the header into a Hash
+          oauth_params = OAuth::Helper.parse_header(header)
 
-        # remove non-OAuth parameters
-        oauth_params.reject! { |k,v| k !~ /^oauth_/ }
+          # remove non-OAuth parameters
+          oauth_params.select! { |k, _v| k =~ /^oauth_/ }
 
-        return oauth_params
+          return oauth_params
+        end
+
+        {}
       end
 
-      return {}
+      # Utility to make parameter values array-style (or keep nil) so that
+      # subclasses can rely on array values for parameter merging/signing.
+      # Mirrors the implementation previously present in
+      # ActionDispatchRequest#wrap_values.
+      def wrap_values(hash)
+        return {} unless hash
+        hash.each_with_object({}) do |(k, v), acc|
+          acc[k] = (v.is_a?(Array) || v.nil?) ? v : [v]
+        end
+      end
     end
   end
 end

data/lib/oauth/request_proxy/curb_request.rb

@@ -1,55 +1,61 @@
-  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
+# frozen_string_literal: true
+
+require "oauth/request_proxy/base"
+require "curb"
+require "uri"
+require "cgi"
+
+module OAuth
+  module RequestProxy
+    module 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 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
+        def parameters
+          if options[:clobber_request]
+            options[:parameters]
+          else
+            post_parameters.merge(query_parameters).merge(options[:parameters] || {})
+          end
+        end
 
-    private
+        private
 
-    def query_parameters
-      query = URI.parse(request.url).query
-      return(query ? CGI.parse(query) : {})
-    end
+        def query_parameters
+          query = URI.parse(request.url).query
+          (query ? CGI.parse(query) : {})
+        end
 
-    def post_parameters
-      post_body = {}
+        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"))
+          # 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]
+            request.post_body.split("&").each do |str|
+              param = str.split("=")
+              post_body[param[0]] = param[1]
+            end
+          end
+          post_body
         end
       end
-      post_body
     end
   end
 end

data/lib/oauth/request_proxy/em_http_request.rb

@@ -1,66 +1,77 @@
-require 'oauth/request_proxy/base'
-# em-http also uses adddressable so there is no need to require uri.
-require 'em-http'
-require 'cgi'
+# frozen_string_literal: true
 
-module OAuth::RequestProxy::EventMachine
-  class HttpRequest < OAuth::RequestProxy::Base
+require "oauth/request_proxy/base"
+require "oauth/optional"
+require "cgi"
 
-    # 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
+if OAuth::Optional.em_http_available?
+  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
 
-    # Request in this con
+          # Request in this con
 
-    def method
-      request.method
-    end
+          def method
+            request.req[:method]
+          end
 
-    def uri
-      request.normalize_uri.to_s
-    end
+          def uri
+            request.conn.normalize.to_s
+          end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters]
-      else
-        all_parameters
-      end
-    end
+          def parameters
+            if options[:clobber_request]
+              options[:parameters]
+            else
+              all_parameters
+            end
+          end
 
-    protected
+          protected
 
-    def all_parameters
-      merged_parameters({}, post_parameters, query_parameters, options[:parameters])
-    end
+          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 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 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 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
+              {}
+            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
+          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
       end
-      params
     end
-
   end
 end

data/lib/oauth/request_proxy/jabber_request.rb

@@ -1,24 +1,34 @@
-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