signet 0.11.0 → 0.14.1

data/lib/signet/oauth_1/credential.rb

@@ -15,6 +15,11 @@
 module Signet #:nodoc:
   module OAuth1
     class Credential
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+
       ##
       # Creates a token object from a key and secret.
       #
@@ -34,7 +39,7 @@ module Signet #:nodoc:
       #   Signet::OAuth1::Credential.new(
       #     "dpf43f3p2l4k3l03", "kd94hf93k423kf44"
       #   )
-      def initialize(*args)
+      def initialize *args
         # We want to be particularly flexible in how we initialize a token
         # object for maximum interoperability.  However, this flexibility
         # means we need to be careful about returning an unexpected value for
@@ -45,73 +50,71 @@ module Signet #:nodoc:
         # indifferent access.  Also uglier.
         key_from_hash = lambda do |parameters|
           parameters["oauth_token"] ||
-          parameters[:oauth_token] ||
-          parameters["key"] ||
-          parameters[:key]
+            parameters[:oauth_token] ||
+            parameters["key"] ||
+            parameters[:key]
         end
         secret_from_hash = lambda do |parameters|
           parameters["oauth_token_secret"] ||
-          parameters[:oauth_token_secret] ||
-          parameters["secret"] ||
-          parameters[:secret]
+            parameters[:oauth_token_secret] ||
+            parameters["secret"] ||
+            parameters[:secret]
         end
-        if args.first.respond_to?(:to_hash)
+        if args.first.respond_to? :to_hash
           parameters = args.first.to_hash
-          @key = key_from_hash.call(parameters)
-          @secret = secret_from_hash.call(parameters)
+          @key = key_from_hash.call parameters
+          @secret = secret_from_hash.call parameters
           unless @key && @secret
             raise ArgumentError,
-              "Could not find both key and secret in #{hash.inspect}."
+                  "Could not find both key and secret in #{hash.inspect}."
           end
         else
           # Normalize to an Array
-          if !args.first.kind_of?(String) &&
-              !args.first.respond_to?(:to_str) &&
-              args.first.kind_of?(Enumerable)
+          if !args.first.is_a?(String) &&
+             !args.first.respond_to?(:to_str) &&
+             args.first.is_a?(Enumerable)
             # We need to special-case strings since they're technically
             # Enumerable objects.
             args = args.first.to_a
-          elsif args.first.respond_to?(:to_ary)
+          elsif args.first.respond_to? :to_ary
             args = args.first.to_ary
           end
-          if args.all? { |value| value.kind_of?(Array) }
-            parameters = args.inject({}) { |h,(k,v)| h[k]=v; h }
-            @key = key_from_hash.call(parameters)
-            @secret = secret_from_hash.call(parameters)
+          if args.all? { |value| value.is_a? Array }
+            parameters = args.each_with_object({}) { |(k, v), h| h[k] = v; }
+            @key = key_from_hash.call parameters
+            @secret = secret_from_hash.call parameters
           elsif args.size == 2
             @key, @secret = args
           else
             raise ArgumentError,
-              "wrong number of arguments (#{args.size} for 2)"
+                  "wrong number of arguments (#{args.size} for 2)"
           end
         end
-        if @key.respond_to?(:to_str)
-          @key = @key.to_str
-        else
-          raise TypeError, "Expected String, got #{@key.class}."
-        end
-        if @secret.respond_to?(:to_str)
-          @secret = @secret.to_str
-        else
-          raise TypeError, "Expected String, got #{@secret.class}."
-        end
+        raise TypeError, "Expected String, got #{@key.class}." unless @key.respond_to? :to_str
+        @key = @key.to_str
+        raise TypeError, "Expected String, got #{@secret.class}." unless @secret.respond_to? :to_str
+        @secret = @secret.to_str
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
 
       attr_accessor :key, :secret
 
       def to_hash
-        return {
-          "oauth_token" => self.key,
-          "oauth_token_secret" => self.secret
+        {
+          "oauth_token"        => key,
+          "oauth_token_secret" => secret
         }
       end
-      alias_method :to_h, :to_hash
+      alias to_h to_hash
 
-      def ==(other)
+      def == other
         if other.respond_to?(:key) && other.respond_to?(:secret)
-          return self.key == other.key && self.secret == other.secret
+          key == other.key && secret == other.secret
         else
-          return false
+          false
         end
       end
     end

data/lib/signet/oauth_1/server.rb

@@ -12,18 +12,17 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-require 'faraday'
-require 'stringio'
-require 'addressable/uri'
-require 'signet'
-require 'signet/errors'
-require 'signet/oauth_1'
-require 'signet/oauth_1/credential'
+require "faraday"
+require "stringio"
+require "addressable/uri"
+require "signet"
+require "signet/errors"
+require "signet/oauth_1"
+require "signet/oauth_1/credential"
 
 module Signet
   module OAuth1
     class Server
-
       # @return [Proc] lookup the value from this Proc.
       attr_accessor :nonce_timestamp, :client_credential, :token_credential,
                     :temporary_credential, :verifier
@@ -50,19 +49,21 @@ module Signet
       #     :verifier =>
       #       lambda {|verifier| Verifier.find_by_verifier(verifier).active? }
       #   )
-      def initialize(options={})
+      def initialize options = {}
         [:nonce_timestamp, :client_credential, :token_credential,
          :temporary_credential, :verifier].each do |attr|
-           instance_variable_set("@#{attr}", options[attr])
+          instance_variable_set "@#{attr}", options[attr]
         end
       end
- 
+      # rubocop:disable Naming/UncommunicativeMethodParamName
+
       # Constant time string comparison.
-      def safe_equals?(a, b)
+      def safe_equals? a, b
         check = a.bytesize ^ b.bytesize
         a.bytes.zip(b.bytes) { |x, y| check |= x ^ y.to_i }
-        check == 0
+        check.zero?
       end
+      # rubocop:enable Naming/UncommunicativeMethodParamName
 
       ##
       # Determine if the supplied nonce/timestamp pair is valid by calling
@@ -71,10 +72,11 @@ module Signet
       # @param [String, #to_str] nonce value from the request
       # @param [String, #to_str] timestamp value from the request
       # @return [Boolean] if the nonce/timestamp pair is valid.
-      def validate_nonce_timestamp(nonce, timestamp)
-        nonce =
-          @nonce_timestamp.call(nonce, timestamp) if
-            @nonce_timestamp.respond_to?(:call)
+      def validate_nonce_timestamp nonce, timestamp
+        if @nonce_timestamp.respond_to? :call
+          nonce =
+            @nonce_timestamp.call nonce, timestamp
+        end
         nonce ? true : false
       end
 
@@ -84,8 +86,8 @@ module Signet
       #
       # @param [String] key provided to the {#client_credential} Proc.
       # @return [Signet::OAuth1::Credential] The client credential.
-      def find_client_credential(key)
-        call_credential_lookup(@client_credential, key)
+      def find_client_credential key
+        call_credential_lookup @client_credential, key
       end
 
       ##
@@ -94,8 +96,8 @@ module Signet
       #
       # @param [String] key provided to the {#token_credential} Proc.
       # @return [Signet::OAuth1::Credential] if the credential is found.
-      def find_token_credential(key)
-        call_credential_lookup(@token_credential, key)
+      def find_token_credential key
+        call_credential_lookup @token_credential, key
       end
 
       ##
@@ -104,8 +106,8 @@ module Signet
       #
       # @param [String] key provided to the {#temporary_credential} Proc.
       # @return [Signet::OAuth1::Credential] if the credential is found.
-      def find_temporary_credential(key)
-        call_credential_lookup(@temporary_credential, key)
+      def find_temporary_credential key
+        call_credential_lookup @temporary_credential, key
       end
 
       ##
@@ -115,17 +117,17 @@ module Signet
       # @param [String] key provided to the Proc in <code>credential</code>
       # @return [Signet::OAuth1::Credential] credential provided by
       #   <code>credential</code> (if any).
-      def call_credential_lookup(credential, key)
-        cred = credential.call(key) if
-                credential.respond_to?(:call)
+      def call_credential_lookup credential, key
+        cred = credential.call key if
+                credential.respond_to? :call
         return nil if cred.nil?
-        return nil unless (cred.respond_to?(:to_str) ||
-                           cred.respond_to?(:to_ary) ||
-                           cred.respond_to?(:to_hash) )
-        if(cred.instance_of?(::Signet::OAuth1::Credential))
+        return nil unless cred.respond_to?(:to_str) ||
+                          cred.respond_to?(:to_ary) ||
+                          cred.respond_to?(:to_hash)
+        if cred.instance_of? ::Signet::OAuth1::Credential
           cred
         else
-          ::Signet::OAuth1::Credential.new(cred)
+          ::Signet::OAuth1::Credential.new cred
         end
       end
 
@@ -135,11 +137,12 @@ module Signet
       # @param [String] verifier Key provided to the {#verifier} Proc.
       # @return [Boolean] if the verifier Proc returns anything other than
       #   <code>nil</code> or <code>false</code>.
-      def find_verifier(verifier)
-        verified = @verifier.call(verifier) if @verifier.respond_to?(:call)
+      def find_verifier verifier
+        verified = @verifier.call verifier if @verifier.respond_to? :call
         verified ? true : false
       end
-
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
 
       ##
       # Validate and normalize the components from an HTTP request.
@@ -151,12 +154,12 @@ module Signet
       #   @param [StringIO, String] body The HTTP body.
       #   @param [HTTPAdapter] adapter The HTTP adapter(optional).
       # @return [Hash] normalized request components
-      def verify_request_components(options={})
+      def verify_request_components options = {}
         if options[:request]
-          if options[:request].kind_of?(Faraday::Request) || options[:request].kind_of?(Array)
+          if options[:request].is_a?(Faraday::Request) || options[:request].is_a?(Array)
             request = options[:request]
           elsif options[:adapter]
-            request = options[:adapter].adapt_request(options[:request])
+            request = options[:adapter].adapt_request options[:request]
           end
           method = request.method
           uri = request.path
@@ -166,45 +169,43 @@ module Signet
           method = options[:method] || :get
           uri = options[:uri]
           headers = options[:headers] || []
-          body = options[:body] || ''
+          body = options[:body] || ""
         end
 
-        headers = headers.to_a if headers.kind_of?(Hash)
+        headers = headers.to_a if headers.is_a? Hash
         method = method.to_s.upcase
 
         request_components = {
-          :method => method,
-          :uri => uri,
-          :headers => headers
+          method:  method,
+          uri:     uri,
+          headers: headers
         }
 
         # Verify that we have all the pieces required to validate the HTTP request
         request_components.each do |(key, value)|
-          unless value
-            raise ArgumentError, "Missing :#{key} parameter."
-          end
+          raise ArgumentError, "Missing :#{key} parameter." unless value
         end
         request_components[:body] = body
         request_components
       end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
 
       ##
       # Validate and normalize the HTTP Authorization header.
       #
       # @param [Array] headers from HTTP request.
       # @return [Hash] Hash of Authorization header.
-      def verify_auth_header_components(headers)
-        auth_header = headers.find{|x| x[0] == 'Authorization'}
-        if(auth_header.nil? || auth_header[1] == '')
-          raise MalformedAuthorizationError.new('Authorization header is missing')
-        end
+      def verify_auth_header_components headers
+        auth_header = headers.find { |x| x[0] == "Authorization" }
+        raise MalformedAuthorizationError, "Authorization header is missing" if auth_header.nil? || auth_header[1] == ""
         auth_hash = ::Signet::OAuth1.parse_authorization_header(
-          auth_header[1] ).inject({}) {|acc, (key,val)| acc[key.downcase] = val; acc}
+          auth_header[1]
+        ).each_with_object({}) { |(key, val), acc| acc[key.downcase] = val; }
 
         auth_hash
       end
 
-
       ##
       # @overload request_realm(options)
       #   @param [Hash] request A pre-constructed request to verify.
@@ -214,27 +215,31 @@ module Signet
       #   @param [StringIO, String] body The HTTP body.
       #   @param [HTTPAdapter] adapter The HTTP adapter(optional).
       # @return [String] The Authorization realm(see RFC 2617) of the request.
-      def request_realm(options={})
-        if(options[:request])
-          request_components = verify_request_components(
-            :request=>options[:request],
-            :adapter=>options[:adapter] )
-        else
-          request_components = verify_request_components(
-            :method=>options[:method],
-            :uri=>options[:uri],
-            :headers=>options[:headers],
-            :body=>options[:body] )
-        end
-
-        auth_header = request_components[:headers].find{|x| x[0] == 'Authorization'}
-        if(auth_header.nil? || auth_header[1] == '')
-          raise MalformedAuthorizationError.new('Authorization header is missing')
-        end
+      def request_realm options = {}
+        request_components = if options[:request]
+                               verify_request_components(
+                                 request: options[:request],
+                                 adapter: options[:adapter]
+                               )
+                             else
+                               verify_request_components(
+                                 method:  options[:method],
+                                 uri:     options[:uri],
+                                 headers: options[:headers],
+                                 body:    options[:body]
+                               )
+                             end
+
+        auth_header = request_components[:headers].find { |x| x[0] == "Authorization" }
+        raise MalformedAuthorizationError, "Authorization header is missing" if auth_header.nil? || auth_header[1] == ""
         auth_hash = ::Signet::OAuth1.parse_authorization_header(
-          auth_header[1] ).inject({}) {|acc, (key,val)| acc[key.downcase] = val; acc}
-        auth_hash['realm']
+          auth_header[1]
+        ).each_with_object({}) { |(key, val), acc| acc[key.downcase] = val; }
+        auth_hash["realm"]
       end
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
 
       ##
       # Authenticates a temporary credential request. If no oauth_callback is
@@ -248,60 +253,62 @@ module Signet
       #   @param [StringIO, String] body The HTTP body.
       #   @param [HTTPAdapter] adapter The HTTP adapter(optional).
       # @return [String] The oauth_callback value, or <code>false</code> if not valid.
-      def authenticate_temporary_credential_request(options={})
+      def authenticate_temporary_credential_request options = {}
         verifications = {
-          :client_credential =>
-            lambda { |x| ::Signet::OAuth1::Credential.new('Client credential key',
-                                                          'Client credential secret'
-                                                         )
-            }
+          client_credential: lambda { |_x|
+                               ::Signet::OAuth1::Credential.new("Client credential key",
+                                                                "Client credential secret")
+                             }
         }
         verifications.each do |(key, _value)|
-          raise ArgumentError, "#{key} was not set." unless self.send(key)
+          raise ArgumentError, "#{key} was not set." unless send key
         end
 
-        if(options[:request])
-          request_components = verify_request_components(
-            :request=>options[:request],
-            :adapter=>options[:adapter] )
-        else
-          request_components = verify_request_components(
-            :method=>options[:method],
-            :uri=>options[:uri],
-            :headers=>options[:headers] )
-        end
+        request_components = if options[:request]
+                               verify_request_components(
+                                 request: options[:request],
+                                 adapter: options[:adapter]
+                               )
+                             else
+                               verify_request_components(
+                                 method:  options[:method],
+                                 uri:     options[:uri],
+                                 headers: options[:headers]
+                               )
+                             end
         # body should be blank; we don't care in any case.
         method = request_components[:method]
         uri = request_components[:uri]
         headers = request_components[:headers]
 
-        auth_hash = verify_auth_header_components(headers)
-        return false unless(client_credential = find_client_credential(
-                                                  auth_hash['oauth_consumer_key']) )
+        auth_hash = verify_auth_header_components headers
+        return false unless (client_credential = find_client_credential(
+          auth_hash["oauth_consumer_key"]
+        ))
 
-        return false unless validate_nonce_timestamp(auth_hash['oauth_nonce'],
-                                                     auth_hash['oauth_timestamp'])
+        return false unless validate_nonce_timestamp(auth_hash["oauth_nonce"],
+                                                     auth_hash["oauth_timestamp"])
         client_credential_secret = client_credential.secret if client_credential
 
         computed_signature = ::Signet::OAuth1.sign_parameters(
           method,
           uri,
           # Realm isn't used, and will throw the signature off.
-          auth_hash.reject{|k,v| k=='realm'}.to_a,
+          auth_hash.reject { |k, _v| k == "realm" }.to_a,
           client_credential_secret,
           nil
         )
-        if safe_equals?(computed_signature, auth_hash['oauth_signature'])
-          if(auth_hash.fetch('oauth_callback', 'oob').empty?)
-            'oob'
+        if safe_equals? computed_signature, auth_hash["oauth_signature"]
+          if auth_hash.fetch("oauth_callback", "oob").empty?
+            "oob"
           else
-            auth_hash.fetch('oauth_callback')
+            auth_hash.fetch "oauth_callback"
           end
         else
           false
         end
       end
-
+      # rubocop:enable Metrics/PerceivedComplexity
 
       ##
       # Authenticates a token credential request.
@@ -314,70 +321,66 @@ module Signet
       #   @param [HTTPAdapter] adapter The HTTP adapter(optional).
       # @return [Hash] A hash of credentials and realm for a valid request,
       #   or <code>nil</code> if not valid.
-      def authenticate_token_credential_request(options={})
+      def authenticate_token_credential_request options = {}
         verifications = {
-          :client_credential =>
-            lambda {|x| ::Signet::OAuth1::Credential.new('Client credential key',
-                                                         'Client credential secret')
-                   },
-          :temporary_credential =>
-            lambda {|x| ::Signet::OAuth1::Credential.new('Temporary credential key',
-                                                         'Temporary credential secret')
-                   },
-          :verifier =>
-            lambda {|x| 'Verifier' }
+          client_credential:    lambda { |_x|
+                                  ::Signet::OAuth1::Credential.new("Client credential key",
+                                                                   "Client credential secret")
+                                },
+          temporary_credential: lambda { |_x|
+                                  ::Signet::OAuth1::Credential.new("Temporary credential key",
+                                                                   "Temporary credential secret")
+                                },
+          verifier:             ->(_x) { "Verifier" }
         }
         verifications.each do |(key, _value)|
-          unless self.send(key)
-            raise ArgumentError, "#{key} was not set."
-          end
-        end
-        if(options[:request])
-          request_components = verify_request_components(
-            :request=>options[:request],
-            :adapter=>options[:adapter]
-          )
-        else
-          request_components = verify_request_components(
-            :method=>options[:method],
-            :uri=>options[:uri],
-            :headers=>options[:headers],
-            :body=>options[:body]
-          )
+          raise ArgumentError, "#{key} was not set." unless send key
         end
+        request_components = if options[:request]
+                               verify_request_components(
+                                 request: options[:request],
+                                 adapter: options[:adapter]
+                               )
+                             else
+                               verify_request_components(
+                                 method:  options[:method],
+                                 uri:     options[:uri],
+                                 headers: options[:headers],
+                                 body:    options[:body]
+                               )
+                             end
         # body should be blank; we don't care in any case.
         method = request_components[:method]
         uri = request_components[:uri]
         headers = request_components[:headers]
 
-        auth_hash = verify_auth_header_components(headers)
-        return false unless(
-          client_credential = find_client_credential(auth_hash['oauth_consumer_key'])
+        auth_hash = verify_auth_header_components headers
+        return false unless (
+          client_credential = find_client_credential auth_hash["oauth_consumer_key"]
         )
-        return false unless(
-          temporary_credential = find_temporary_credential(auth_hash['oauth_token'])
+        return false unless (
+          temporary_credential = find_temporary_credential auth_hash["oauth_token"]
         )
         return false unless validate_nonce_timestamp(
-          auth_hash['oauth_nonce'], auth_hash['oauth_timestamp'])
+          auth_hash["oauth_nonce"], auth_hash["oauth_timestamp"]
+        )
 
         computed_signature = ::Signet::OAuth1.sign_parameters(
           method,
           uri,
           # Realm isn't used, and will throw the signature off.
-          auth_hash.reject{|k,v| k=='realm'}.to_a,
+          auth_hash.reject { |k, _v| k == "realm" }.to_a,
           client_credential.secret,
           temporary_credential.secret
         )
 
-        if safe_equals?(computed_signature, auth_hash['oauth_signature'])
-          {:client_credential=>client_credential,
-            :temporary_credential=>temporary_credential,
-            :realm=>auth_hash['realm']
-          }
-        else
-          nil
-        end
+        return nil unless safe_equals? computed_signature, auth_hash["oauth_signature"]
+        { client_credential:    client_credential,
+          temporary_credential: temporary_credential,
+          realm:                auth_hash["realm"] }
       end
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
 
       ##
       # Authenticates a request for a protected resource.
@@ -392,96 +395,88 @@ module Signet
       #
       # @return [Hash] A hash of the credentials and realm for a valid request,
       #   or <code>nil</code> if not valid.
-      def authenticate_resource_request(options={})
+      def authenticate_resource_request options = {}
         verifications = {
-          :client_credential =>
-            lambda do |x|
-              ::Signet::OAuth1::Credential.new('Client credential key',
-                                               'Client credential secret')
-            end
+          client_credential: lambda do |_x|
+                               ::Signet::OAuth1::Credential.new("Client credential key",
+                                                                "Client credential secret")
+                             end
         }
 
-        unless(options[:two_legged] == true)
+        unless options[:two_legged] == true
           verifications.update(
-            :token_credential =>
-              lambda do |x|
-                ::Signet::OAuth1::Credential.new('Token credential key',
-                                                 'Token credential secret')
-              end
+            token_credential: lambda do |_x|
+                                ::Signet::OAuth1::Credential.new("Token credential key",
+                                                                 "Token credential secret")
+                              end
           )
         end
         # Make sure all required state is set
         verifications.each do |(key, _value)|
-          unless self.send(key)
-            raise ArgumentError, "#{key} was not set."
-          end
+          raise ArgumentError, "#{key} was not set." unless send key
         end
 
-        if(options[:request])
-          request_components = verify_request_components(
-            :request=>options[:request],
-            :adapter=>options[:adapter] )
-        else
-          request_components = verify_request_components(
-            :method=>options[:method],
-            :uri=>options[:uri],
-            :headers=>options[:headers],
-            :body=>options[:body] )
-        end
+        request_components = if options[:request]
+                               verify_request_components(
+                                 request: options[:request],
+                                 adapter: options[:adapter]
+                               )
+                             else
+                               verify_request_components(
+                                 method:  options[:method],
+                                 uri:     options[:uri],
+                                 headers: options[:headers],
+                                 body:    options[:body]
+                               )
+                             end
         method = request_components[:method]
         uri = request_components[:uri]
         headers = request_components[:headers]
         body = request_components[:body]
 
 
-        if !body.kind_of?(String) && body.respond_to?(:each)
+        if !body.is_a?(String) && body.respond_to?(:each)
           # Just in case we get a chunked body
           merged_body = StringIO.new
           body.each do |chunk|
-            merged_body.write(chunk)
+            merged_body.write chunk
           end
           body = merged_body.string
         end
-        if !body.kind_of?(String)
-          raise TypeError, "Expected String, got #{body.class}."
-        end
+        raise TypeError, "Expected String, got #{body.class}." unless body.is_a? String
 
         media_type = nil
         headers.each do |(header, value)|
-          if header.downcase == 'Content-Type'.downcase
-            media_type = value.gsub(/^([^;]+)(;.*?)?$/, '\1')
-          end
+          media_type = value.gsub(/^([^;]+)(;.*?)?$/, '\1') if header.casecmp("Content-Type").zero?
         end
 
-        auth_hash = verify_auth_header_components(headers)
+        auth_hash = verify_auth_header_components headers
 
-        auth_token = auth_hash['oauth_token']
+        auth_token = auth_hash["oauth_token"]
 
 
-        unless(options[:two_legged])
-          return nil if(auth_token.nil?)
-          return nil unless(token_credential = find_token_credential(auth_token))
+        unless options[:two_legged]
+          return nil if auth_token.nil?
+          return nil unless (token_credential = find_token_credential auth_token)
           token_credential_secret = token_credential.secret if token_credential
         end
 
-        return nil unless(client_credential =
-                            find_client_credential(auth_hash['oauth_consumer_key']))
+        return nil unless (client_credential =
+                             find_client_credential auth_hash["oauth_consumer_key"])
 
-        return nil unless validate_nonce_timestamp(auth_hash['oauth_nonce'],
-                                                     auth_hash['oauth_timestamp'])
+        return nil unless validate_nonce_timestamp(auth_hash["oauth_nonce"],
+                                                   auth_hash["oauth_timestamp"])
 
-        if(method == ('POST' || 'PUT') &&
-           media_type == 'application/x-www-form-urlencoded')
+        if method == ("POST" || "PUT") &&
+           media_type == "application/x-www-form-urlencoded"
           request_components[:body] = body
-          post_parameters = Addressable::URI.form_unencode(body)
-          post_parameters.each {|param| param[1] = "" if param[1].nil?}
+          post_parameters = Addressable::URI.form_unencode body
+          post_parameters.each { |param| param[1] = "" if param[1].nil? }
           # If the auth header doesn't have the same params as the body, it
           # can't have been signed correctly(5849#3.4.1.3)
-          unless(post_parameters.sort == auth_hash.reject{|k,v| k.index('oauth_')}.to_a.sort)
-            raise MalformedAuthorizationError.new(
-              'Request is of type application/x-www-form-urlencoded ' +
-              'but Authentication header did not include form values'
-                                                 )
+          unless post_parameters.sort == auth_hash.reject { |k, _v| k.index "oauth_" }.to_a.sort
+            raise MalformedAuthorizationError, "Request is of type application/x-www-form-urlencoded " \
+              "but Authentication header did not include form values"
           end
         end
 
@@ -491,21 +486,20 @@ module Signet
           method,
           uri,
           # Realm isn't used, and will throw the signature off.
-          auth_hash.reject{|k,v| k=='realm'}.to_a,
+          auth_hash.reject { |k, _v| k == "realm" }.to_a,
           client_credential_secret,
           token_credential_secret
         )
 
-        if safe_equals?(computed_signature, auth_hash['oauth_signature'])
-          {:client_credential=>client_credential,
-           :token_credential=>token_credential,
-           :realm=>auth_hash['realm']
-          }
-        else
-          nil
-        end
+        return nil unless safe_equals? computed_signature, auth_hash["oauth_signature"]
+        { client_credential: client_credential,
+          token_credential:  token_credential,
+          realm:             auth_hash["realm"] }
       end
-
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end