signet 0.11.0 → 0.14.1

data/lib/signet/oauth_1/client.rb

@@ -12,15 +12,15 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-require 'faraday'
-#require 'faraday/utils'
+require "faraday"
+# require 'faraday/utils'
 
-require 'stringio'
-require 'addressable/uri'
-require 'signet'
-require 'signet/errors'
-require 'signet/oauth_1'
-require 'signet/oauth_1/credential'
+require "stringio"
+require "addressable/uri"
+require "signet"
+require "signet/errors"
+require "signet/oauth_1"
+require "signet/oauth_1/credential"
 
 module Signet
   module OAuth1
@@ -53,8 +53,8 @@ module Signet
       #     :client_credential_key => 'anonymous',
       #     :client_credential_secret => 'anonymous'
       #   )
-      def initialize(options={})
-        self.update!(options)
+      def initialize options = {}
+        update! options
       end
 
       ##
@@ -87,29 +87,29 @@ module Signet
       #   )
       #
       # @see Signet::OAuth1::Client#initialize
-      def update!(options={})
+      def update! options = {}
         # Normalize key to String to allow indifferent access.
-        options = options.inject({}) { |accu, (k, v)| accu[k.to_s] = v; accu }
+        options = options.each_with_object({}) { |(k, v), accu| accu[k.to_s] = v; }
         self.temporary_credential_uri = options["temporary_credential_uri"]
         self.authorization_uri = options["authorization_uri"]
         self.token_credential_uri = options["token_credential_uri"]
         # Technically... this would allow you to pass in a :client key...
         # But that would be weird.  Don't do that.
         self.client_credential_key =
-          Signet::OAuth1.extract_credential_key_option("client", options)
+          Signet::OAuth1.extract_credential_key_option "client", options
         self.client_credential_secret =
-          Signet::OAuth1.extract_credential_secret_option("client", options)
+          Signet::OAuth1.extract_credential_secret_option "client", options
         self.temporary_credential_key =
-          Signet::OAuth1.extract_credential_key_option("temporary", options)
+          Signet::OAuth1.extract_credential_key_option "temporary", options
         self.temporary_credential_secret =
-          Signet::OAuth1.extract_credential_secret_option("temporary", options)
+          Signet::OAuth1.extract_credential_secret_option "temporary", options
         self.token_credential_key =
-          Signet::OAuth1.extract_credential_key_option("token", options)
+          Signet::OAuth1.extract_credential_key_option "token", options
         self.token_credential_secret =
-          Signet::OAuth1.extract_credential_secret_option("token", options)
+          Signet::OAuth1.extract_credential_secret_option "token", options
         self.callback = options["callback"]
         self.two_legged = options["two_legged"] || false
-        return self
+        self
       end
 
       ##
@@ -117,9 +117,9 @@ module Signet
       #
       # @return [Addressable::URI] The temporary credentials URI.
       def temporary_credential_uri
-        return @temporary_credential_uri
+        @temporary_credential_uri
       end
-      alias_method :request_token_uri, :temporary_credential_uri
+      alias request_token_uri temporary_credential_uri
 
       ##
       # Sets the temporary credentials URI for this client.
@@ -127,16 +127,16 @@ module Signet
       # @param [Addressable::URI, String, #to_str]
       #   new_temporary_credential_uri
       #   The temporary credentials URI.
-      def temporary_credential_uri=(new_temporary_credential_uri)
-        if new_temporary_credential_uri != nil
+      def temporary_credential_uri= new_temporary_credential_uri
+        if !new_temporary_credential_uri.nil?
           new_temporary_credential_uri =
-            Addressable::URI.parse(new_temporary_credential_uri)
+            Addressable::URI.parse new_temporary_credential_uri
           @temporary_credential_uri = new_temporary_credential_uri
         else
           @temporary_credential_uri = nil
         end
       end
-      alias_method :request_token_uri=, :temporary_credential_uri=
+      alias request_token_uri= temporary_credential_uri=
 
       ##
       # Returns the authorization URI that the user should be redirected to.
@@ -144,13 +144,13 @@ module Signet
       # @return [Addressable::URI] The authorization URI.
       #
       # @see Signet::OAuth1.generate_authorization_uri
-      def authorization_uri(options={})
+      def authorization_uri options = {}
         options = options.merge(
-          :temporary_credential_key => self.temporary_credential_key,
-          :callback => self.callback
+          temporary_credential_key: temporary_credential_key,
+          callback:                 callback
         )
-        return nil if @authorization_uri == nil
-        return Addressable::URI.parse(
+        return nil if @authorization_uri.nil?
+        Addressable::URI.parse(
           ::Signet::OAuth1.generate_authorization_uri(
             @authorization_uri, options
           )
@@ -162,10 +162,10 @@ module Signet
       #
       # @param [Addressable::URI, String, #to_str] new_authorization_uri
       #   The authorization URI.
-      def authorization_uri=(new_authorization_uri)
-        if new_authorization_uri != nil
+      def authorization_uri= new_authorization_uri
+        if !new_authorization_uri.nil?
           new_authorization_uri = Addressable::URI.send(
-            new_authorization_uri.kind_of?(Hash) ? :new : :parse,
+            new_authorization_uri.is_a?(Hash) ? :new : :parse,
             new_authorization_uri
           )
           @authorization_uri = new_authorization_uri
@@ -179,19 +179,19 @@ module Signet
       #
       # @return [Addressable::URI] The token credential URI.
       def token_credential_uri
-        return @token_credential_uri
+        @token_credential_uri
       end
-      alias_method :access_token_uri, :token_credential_uri
+      alias access_token_uri token_credential_uri
 
       ##
       # Sets the token credential URI for this client.
       #
       # @param [Addressable::URI, Hash, String, #to_str] new_token_credential_uri
       #   The token credential URI.
-      def token_credential_uri=(new_token_credential_uri)
-        if new_token_credential_uri != nil
+      def token_credential_uri= new_token_credential_uri
+        if !new_token_credential_uri.nil?
           new_token_credential_uri = Addressable::URI.send(
-            new_token_credential_uri.kind_of?(Hash) ? :new : :parse,
+            new_token_credential_uri.is_a?(Hash) ? :new : :parse,
             new_token_credential_uri
           )
           @token_credential_uri = new_token_credential_uri
@@ -199,7 +199,7 @@ module Signet
           @token_credential_uri = nil
         end
       end
-      alias_method :access_token_uri=, :token_credential_uri=
+      alias access_token_uri= token_credential_uri=
 
       # Lots of duplicated code here, but for the sake of auto-generating
       # documentation, we're going to let it slide.  Oh well.
@@ -209,31 +209,31 @@ module Signet
       #
       # @return [Signet::OAuth1::Credential] The client credentials.
       def client_credential
-        if self.client_credential_key && self.client_credential_secret
-          return ::Signet::OAuth1::Credential.new(
-            self.client_credential_key,
-            self.client_credential_secret
+        if client_credential_key && client_credential_secret
+          ::Signet::OAuth1::Credential.new(
+            client_credential_key,
+            client_credential_secret
           )
-        elsif !self.client_credential_key && !self.client_credential_secret
-          return nil
+        elsif !client_credential_key && !client_credential_secret
+          nil
         else
           raise ArgumentError,
-            "The client credential key and secret must be set."
+                "The client credential key and secret must be set."
         end
       end
-      alias_method :consumer_token, :client_credential
+      alias consumer_token client_credential
 
       ##
       # Sets the client credential for this client.
       #
       # @param [Signet::OAuth1::Credential] new_client_credential
       #   The client credentials.
-      def client_credential=(new_client_credential)
-        if new_client_credential != nil
-          if !new_client_credential.kind_of?(::Signet::OAuth1::Credential)
+      def client_credential= new_client_credential
+        if !new_client_credential.nil?
+          unless new_client_credential.is_a? ::Signet::OAuth1::Credential
             raise TypeError,
-              "Expected Signet::OAuth1::Credential, " +
-              "got #{new_client_credential.class}."
+                  "Expected Signet::OAuth1::Credential, " \
+                  "got #{new_client_credential.class}."
           end
           @client_credential_key = new_client_credential.key
           @client_credential_secret = new_client_credential.secret
@@ -242,27 +242,27 @@ module Signet
           @client_credential_secret = nil
         end
       end
-      alias_method :consumer_token=, :client_credential=
+      alias consumer_token= client_credential=
 
       ##
       # Returns the client credential key for this client.
       #
       # @return [String] The client credential key.
       def client_credential_key
-        return @client_credential_key
+        @client_credential_key
       end
-      alias_method :consumer_key, :client_credential_key
+      alias consumer_key client_credential_key
 
       ##
       # Sets the client credential key for this client.
       #
       # @param [String, #to_str] new_client_credential_key
       #   The client credential key.
-      def client_credential_key=(new_client_credential_key)
-        if new_client_credential_key != nil
-          if !new_client_credential_key.respond_to?(:to_str)
+      def client_credential_key= new_client_credential_key
+        if !new_client_credential_key.nil?
+          unless new_client_credential_key.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_client_credential_key.class} into String."
+                  "Can't convert #{new_client_credential_key.class} into String."
           end
           new_client_credential_key = new_client_credential_key.to_str
           @client_credential_key = new_client_credential_key
@@ -270,28 +270,28 @@ module Signet
           @client_credential_key = nil
         end
       end
-      alias_method :consumer_key=, :client_credential_key=
+      alias consumer_key= client_credential_key=
 
       ##
       # Returns the client credential secret for this client.
       #
       # @return [String] The client credential secret.
       def client_credential_secret
-        return @client_credential_secret
+        @client_credential_secret
       end
-      alias_method :consumer_secret, :client_credential_secret
+      alias consumer_secret client_credential_secret
 
       ##
       # Sets the client credential secret for this client.
       #
       # @param [String, #to_str] new_client_credential_secret
       #   The client credential secret.
-      def client_credential_secret=(new_client_credential_secret)
-        if new_client_credential_secret != nil
-          if !new_client_credential_secret.respond_to?(:to_str)
+      def client_credential_secret= new_client_credential_secret
+        if !new_client_credential_secret.nil?
+          unless new_client_credential_secret.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_client_credential_secret.class} " +
-              "into String."
+                  "Can't convert #{new_client_credential_secret.class} " \
+                  "into String."
           end
           new_client_credential_secret = new_client_credential_secret.to_str
           @client_credential_secret = new_client_credential_secret
@@ -299,39 +299,39 @@ module Signet
           @client_credential_secret = nil
         end
       end
-      alias_method :consumer_secret=, :client_credential_secret=
+      alias consumer_secret= client_credential_secret=
 
       ##
       # Returns the temporary credential for this client.
       #
       # @return [Signet::OAuth1::Credential] The temporary credentials.
       def temporary_credential
-        if self.temporary_credential_key && self.temporary_credential_secret
-          return ::Signet::OAuth1::Credential.new(
-            self.temporary_credential_key,
-            self.temporary_credential_secret
+        if temporary_credential_key && temporary_credential_secret
+          ::Signet::OAuth1::Credential.new(
+            temporary_credential_key,
+            temporary_credential_secret
           )
-        elsif !self.temporary_credential_key &&
-            !self.temporary_credential_secret
-          return nil
+        elsif !temporary_credential_key &&
+              !temporary_credential_secret
+          nil
         else
           raise ArgumentError,
-            "The temporary credential key and secret must be set."
+                "The temporary credential key and secret must be set."
         end
       end
-      alias_method :request_token, :temporary_credential
+      alias request_token temporary_credential
 
       ##
       # Sets the temporary credential for this client.
       #
       # @param [Signet::OAuth1::Credential] new_temporary_credential
       #   The temporary credentials.
-      def temporary_credential=(new_temporary_credential)
-        if new_temporary_credential != nil
-          if !new_temporary_credential.kind_of?(::Signet::OAuth1::Credential)
+      def temporary_credential= new_temporary_credential
+        if !new_temporary_credential.nil?
+          unless new_temporary_credential.is_a? ::Signet::OAuth1::Credential
             raise TypeError,
-              "Expected Signet::OAuth1::Credential, " +
-              "got #{new_temporary_credential.class}."
+                  "Expected Signet::OAuth1::Credential, " \
+                  "got #{new_temporary_credential.class}."
           end
           @temporary_credential_key = new_temporary_credential.key
           @temporary_credential_secret = new_temporary_credential.secret
@@ -340,28 +340,28 @@ module Signet
           @temporary_credential_secret = nil
         end
       end
-      alias_method :request_token=, :temporary_credential=
+      alias request_token= temporary_credential=
 
       ##
       # Returns the temporary credential key for this client.
       #
       # @return [String] The temporary credential key.
       def temporary_credential_key
-        return @temporary_credential_key
+        @temporary_credential_key
       end
-      alias_method :request_token_key, :temporary_credential_key
+      alias request_token_key temporary_credential_key
 
       ##
       # Sets the temporary credential key for this client.
       #
       # @param [String, #to_str] new_temporary_credential_key
       #   The temporary credential key.
-      def temporary_credential_key=(new_temporary_credential_key)
-        if new_temporary_credential_key != nil
-          if !new_temporary_credential_key.respond_to?(:to_str)
+      def temporary_credential_key= new_temporary_credential_key
+        if !new_temporary_credential_key.nil?
+          unless new_temporary_credential_key.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_temporary_credential_key.class} " +
-              "into String."
+                  "Can't convert #{new_temporary_credential_key.class} " \
+                  "into String."
           end
           new_temporary_credential_key = new_temporary_credential_key.to_str
           @temporary_credential_key = new_temporary_credential_key
@@ -369,28 +369,28 @@ module Signet
           @temporary_credential_key = nil
         end
       end
-      alias_method :request_token_key=, :temporary_credential_key=
+      alias request_token_key= temporary_credential_key=
 
       ##
       # Returns the temporary credential secret for this client.
       #
       # @return [String] The temporary credential secret.
       def temporary_credential_secret
-        return @temporary_credential_secret
+        @temporary_credential_secret
       end
-      alias_method :request_token_secret, :temporary_credential_secret
+      alias request_token_secret temporary_credential_secret
 
       ##
       # Sets the temporary credential secret for this client.
       #
       # @param [String, #to_str] new_temporary_credential_secret
       #   The temporary credential secret.
-      def temporary_credential_secret=(new_temporary_credential_secret)
-        if new_temporary_credential_secret != nil
-          if !new_temporary_credential_secret.respond_to?(:to_str)
+      def temporary_credential_secret= new_temporary_credential_secret
+        if !new_temporary_credential_secret.nil?
+          unless new_temporary_credential_secret.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_temporary_credential_secret.class} " +
-              "into String."
+                  "Can't convert #{new_temporary_credential_secret.class} " \
+                  "into String."
           end
           new_temporary_credential_secret =
             new_temporary_credential_secret.to_str
@@ -399,39 +399,39 @@ module Signet
           @temporary_credential_secret = nil
         end
       end
-      alias_method :request_token_secret=, :temporary_credential_secret=
+      alias request_token_secret= temporary_credential_secret=
 
       ##
       # Returns the token credential for this client.
       #
       # @return [Signet::OAuth1::Credential] The token credentials.
       def token_credential
-        if self.token_credential_key && self.token_credential_secret
-          return ::Signet::OAuth1::Credential.new(
-            self.token_credential_key,
-            self.token_credential_secret
+        if token_credential_key && token_credential_secret
+          ::Signet::OAuth1::Credential.new(
+            token_credential_key,
+            token_credential_secret
           )
-        elsif !self.token_credential_key &&
-            !self.token_credential_secret
-          return nil
+        elsif !token_credential_key &&
+              !token_credential_secret
+          nil
         else
           raise ArgumentError,
-            "The token credential key and secret must be set."
+                "The token credential key and secret must be set."
         end
       end
-      alias_method :access_token, :token_credential
+      alias access_token token_credential
 
       ##
       # Sets the token credential for this client.
       #
       # @param [Signet::OAuth1::Credential] new_token_credential
       #   The token credentials.
-      def token_credential=(new_token_credential)
-        if new_token_credential != nil
-          if !new_token_credential.kind_of?(::Signet::OAuth1::Credential)
+      def token_credential= new_token_credential
+        if !new_token_credential.nil?
+          unless new_token_credential.is_a? ::Signet::OAuth1::Credential
             raise TypeError,
-              "Expected Signet::OAuth1::Credential, " +
-              "got #{new_token_credential.class}."
+                  "Expected Signet::OAuth1::Credential, " \
+                  "got #{new_token_credential.class}."
           end
           @token_credential_key = new_token_credential.key
           @token_credential_secret = new_token_credential.secret
@@ -440,28 +440,28 @@ module Signet
           @token_credential_secret = nil
         end
       end
-      alias_method :access_token=, :token_credential=
+      alias access_token= token_credential=
 
       ##
       # Returns the token credential key for this client.
       #
       # @return [String] The token credential key.
       def token_credential_key
-        return @token_credential_key
+        @token_credential_key
       end
-      alias_method :access_token_key, :token_credential_key
+      alias access_token_key token_credential_key
 
       ##
       # Sets the token credential key for this client.
       #
       # @param [String, #to_str] new_token_credential_key
       #   The token credential key.
-      def token_credential_key=(new_token_credential_key)
-        if new_token_credential_key != nil
-          if !new_token_credential_key.respond_to?(:to_str)
+      def token_credential_key= new_token_credential_key
+        if !new_token_credential_key.nil?
+          unless new_token_credential_key.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_token_credential_key.class} " +
-              "into String."
+                  "Can't convert #{new_token_credential_key.class} " \
+                  "into String."
           end
           new_token_credential_key = new_token_credential_key.to_str
           @token_credential_key = new_token_credential_key
@@ -469,28 +469,28 @@ module Signet
           @token_credential_key = nil
         end
       end
-      alias_method :access_token_key=, :token_credential_key=
+      alias access_token_key= token_credential_key=
 
       ##
       # Returns the token credential secret for this client.
       #
       # @return [String] The token credential secret.
       def token_credential_secret
-        return @token_credential_secret
+        @token_credential_secret
       end
-      alias_method :access_token_secret, :token_credential_secret
+      alias access_token_secret token_credential_secret
 
       ##
       # Sets the token credential secret for this client.
       #
       # @param [String, #to_str] new_token_credential_secret
       #   The token credential secret.
-      def token_credential_secret=(new_token_credential_secret)
-        if new_token_credential_secret != nil
-          if !new_token_credential_secret.respond_to?(:to_str)
+      def token_credential_secret= new_token_credential_secret
+        if !new_token_credential_secret.nil?
+          unless new_token_credential_secret.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_token_credential_secret.class} " +
-              "into String."
+                  "Can't convert #{new_token_credential_secret.class} " \
+                  "into String."
           end
           new_token_credential_secret =
             new_token_credential_secret.to_str
@@ -499,14 +499,14 @@ module Signet
           @token_credential_secret = nil
         end
       end
-      alias_method :access_token_secret=, :token_credential_secret=
+      alias access_token_secret= token_credential_secret=
 
       ##
       # Returns the callback for this client.
       #
       # @return [String] The OAuth callback.
       def callback
-        return @callback || ::Signet::OAuth1::OUT_OF_BAND
+        @callback || ::Signet::OAuth1::OUT_OF_BAND
       end
 
       ##
@@ -514,11 +514,11 @@ module Signet
       #
       # @param [String, #to_str] new_callback
       #   The OAuth callback.
-      def callback=(new_callback)
-        if new_callback != nil
-          if !new_callback.respond_to?(:to_str)
+      def callback= new_callback
+        if !new_callback.nil?
+          unless new_callback.respond_to? :to_str
             raise TypeError,
-              "Can't convert #{new_callback.class} into String."
+                  "Can't convert #{new_callback.class} into String."
           end
           new_callback = new_callback.to_str
           @callback = new_callback
@@ -533,7 +533,7 @@ module Signet
       # @return [TrueClass, FalseClass]
       #   <code>true</code> for two-legged mode, <code>false</code> otherwise.
       def two_legged
-        return @two_legged ||= false
+        @two_legged ||= false
       end
 
       ##
@@ -541,10 +541,10 @@ module Signet
       #
       # @param [TrueClass, FalseClass] new_two_legged
       #   <code>true</code> for two-legged mode, <code>false</code> otherwise.
-      def two_legged=(new_two_legged)
+      def two_legged= new_two_legged
         if new_two_legged != true && new_two_legged != false
           raise TypeError,
-            "Expected true or false, got #{new_two_legged.class}."
+                "Expected true or false, got #{new_two_legged.class}."
         else
           @two_legged = new_two_legged
         end
@@ -557,20 +557,22 @@ module Signet
       #
       # @return [String] A serialized JSON representation of the client.
       def to_json
-        return MultiJson.dump({
-          'temporary_credential_uri' => self.temporary_credential_uri,
-          'authorization_uri' => self.authorization_uri,
-          'token_credential_uri' => self.token_credential_uri,
-          'callback' => self.callback,
-          'two_legged' => self.two_legged,
-          'client_credential_key' => self.client_credential_key,
-          'client_credential_secret' => self.client_credential_secret,
-          'temporary_credential_key' => self.temporary_credential_key,
-          'temporary_credential_secret' => self.temporary_credential_secret,
-          'token_credential_key' => self.token_credential_key,
-          'token_credential_secret' => self.token_credential_secret
-        })
+        MultiJson.dump(
+          "temporary_credential_uri"    => temporary_credential_uri,
+          "authorization_uri"           => authorization_uri,
+          "token_credential_uri"        => token_credential_uri,
+          "callback"                    => callback,
+          "two_legged"                  => two_legged,
+          "client_credential_key"       => client_credential_key,
+          "client_credential_secret"    => client_credential_secret,
+          "temporary_credential_key"    => temporary_credential_key,
+          "temporary_credential_secret" => temporary_credential_secret,
+          "token_credential_key"        => token_credential_key,
+          "token_credential_secret"     => token_credential_secret
+        )
       end
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
 
       ##
       # Generates a request for temporary credentials.
@@ -585,60 +587,57 @@ module Signet
       #     The Authorization realm.  See RFC 2617.
       #
       # @return [Array] The request object.
-      def generate_temporary_credential_request(options={})
+      def generate_temporary_credential_request options = {}
         verifications = {
-          :temporary_credential_uri => 'Temporary credentials URI',
-          :client_credential_key => 'Client credential key',
-          :client_credential_secret => 'Client credential secret'
+          temporary_credential_uri: "Temporary credentials URI",
+          client_credential_key:    "Client credential key",
+          client_credential_secret: "Client credential secret"
         }
         # 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
         options = {
-          :signature_method => 'HMAC-SHA1',
-          :additional_parameters => [],
-          :realm => nil,
-          :connection => Faraday.default_connection
+          signature_method:      "HMAC-SHA1",
+          additional_parameters: [],
+          realm:                 nil,
+          connection:            Faraday.default_connection
         }.merge(options)
         method = :post
         parameters = ::Signet::OAuth1.unsigned_temporary_credential_parameters(
-          :client_credential_key => self.client_credential_key,
-          :callback => self.callback,
-          :signature_method => options[:signature_method],
-          :additional_parameters => options[:additional_parameters]
+          client_credential_key: client_credential_key,
+          callback:              callback,
+          signature_method:      options[:signature_method],
+          additional_parameters: options[:additional_parameters]
         )
         signature = ::Signet::OAuth1.sign_parameters(
           method,
-          self.temporary_credential_uri,
+          temporary_credential_uri,
           parameters,
-          self.client_credential_secret
+          client_credential_secret
         )
-        parameters << ['oauth_signature', signature]
+        parameters << ["oauth_signature", signature]
         authorization_header = [
-          'Authorization',
+          "Authorization",
           ::Signet::OAuth1.generate_authorization_header(
             parameters, options[:realm]
           )
         ]
         headers = [authorization_header]
         if method == :post
-          headers << ['Content-Type', 'application/x-www-form-urlencoded']
-          headers << ['Content-Length', '0']
+          headers << ["Content-Type", "application/x-www-form-urlencoded"]
+          headers << ["Content-Length", "0"]
         end
-        return options[:connection].build_request(method.to_s.downcase.to_sym) do |req|
+        options[:connection].build_request method.to_s.downcase.to_sym do |req|
           req.url(Addressable::URI.parse(
-            self.temporary_credential_uri.to_str
+            temporary_credential_uri.to_str
           ).normalize.to_s)
-          req.headers = Faraday::Utils::Headers.new(headers)
+          req.headers = Faraday::Utils::Headers.new headers
         end
       end
-      alias_method(
-        :generate_request_token_request,
-        :generate_temporary_credential_request
-      )
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      alias generate_request_token_request generate_temporary_credential_request
 
       ##
       # Transmits a request for a temporary credential.  This method does not
@@ -664,36 +663,24 @@ module Signet
       #       :scope => 'https://mail.google.com/mail/feed/atom'
       #     }
       #   )
-      def fetch_temporary_credential(options={})
+      def fetch_temporary_credential options = {}
         options[:connection] ||= Faraday.default_connection
-        request = self.generate_temporary_credential_request(options)
-        request_env = request.to_env(options[:connection])
+        request = generate_temporary_credential_request options
+        request_env = request.to_env options[:connection]
         request_env[:request] ||= request
-        response = options[:connection].app.call(request_env)
-        if response.status.to_i == 200
-          return ::Signet::OAuth1.parse_form_encoded_credentials(response.body)
-        elsif [400, 401, 403].include?(response.status.to_i)
-          message = 'Authorization failed.'
-          if response.body.to_s.strip.length > 0
-            message += "  Server message:\n#{response.body.to_s.strip}"
-          end
-          raise ::Signet::AuthorizationError.new(
-            message, :request => request, :response => response
-          )
-        else
-          message = "Unexpected status code: #{response.status}."
-          if response.body.to_s.strip.length > 0
-            message += "  Server message:\n#{response.body.to_s.strip}"
-          end
-          raise ::Signet::AuthorizationError.new(
-            message, :request => request, :response => response
-          )
-        end
+        response = options[:connection].app.call request_env
+        return ::Signet::OAuth1.parse_form_encoded_credentials response.body if response.status.to_i == 200
+        message = if [400, 401, 403].include? response.status.to_i
+                    "Authorization failed."
+                  else
+                    "Unexpected status code: #{response.status}."
+                  end
+        message += "  Server message:\n#{response.body.to_s.strip}" unless response.body.to_s.strip.empty?
+        raise ::Signet::AuthorizationError.new(
+          message, request: request, response: response
+        )
       end
-      alias_method(
-        :fetch_request_token,
-        :fetch_temporary_credential
-      )
+      alias fetch_request_token fetch_temporary_credential
 
       ##
       # Transmits a request for a temporary credential.  This method updates
@@ -717,14 +704,13 @@ module Signet
       #   client.fetch_temporary_credential!(:additional_parameters => {
       #     :scope => 'https://mail.google.com/mail/feed/atom'
       #   })
-      def fetch_temporary_credential!(options={})
-        credential = self.fetch_temporary_credential(options)
+      def fetch_temporary_credential! options = {}
+        credential = fetch_temporary_credential options
         self.temporary_credential = credential
       end
-      alias_method(
-        :fetch_request_token!,
-        :fetch_temporary_credential!
-      )
+      alias fetch_request_token! fetch_temporary_credential!
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
 
       ##
       # Generates a request for token credentials.
@@ -739,63 +725,59 @@ module Signet
       #     The Authorization realm.  See RFC 2617.
       #
       # @return [Array] The request object.
-      def generate_token_credential_request(options={})
+      def generate_token_credential_request options = {}
         verifications = {
-          :token_credential_uri => 'Token credentials URI',
-          :client_credential_key => 'Client credential key',
-          :client_credential_secret => 'Client credential secret',
-          :temporary_credential_key => 'Temporary credential key',
-          :temporary_credential_secret => 'Temporary credential secret'
+          token_credential_uri:        "Token credentials URI",
+          client_credential_key:       "Client credential key",
+          client_credential_secret:    "Client credential secret",
+          temporary_credential_key:    "Temporary credential key",
+          temporary_credential_secret: "Temporary credential secret"
         }
         # 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
         options = {
-          :signature_method => 'HMAC-SHA1',
-          :realm => nil,
-          :connection => Faraday.default_connection
+          signature_method: "HMAC-SHA1",
+          realm:            nil,
+          connection:       Faraday.default_connection
         }.merge(options)
         method = :post
         parameters = ::Signet::OAuth1.unsigned_token_credential_parameters(
-          :client_credential_key => self.client_credential_key,
-          :temporary_credential_key => self.temporary_credential_key,
-          :signature_method => options[:signature_method],
-          :verifier => options[:verifier]
+          client_credential_key:    client_credential_key,
+          temporary_credential_key: temporary_credential_key,
+          signature_method:         options[:signature_method],
+          verifier:                 options[:verifier]
         )
         signature = ::Signet::OAuth1.sign_parameters(
           method,
-          self.token_credential_uri,
+          token_credential_uri,
           parameters,
-          self.client_credential_secret,
-          self.temporary_credential_secret
+          client_credential_secret,
+          temporary_credential_secret
         )
-        parameters << ['oauth_signature', signature]
+        parameters << ["oauth_signature", signature]
         authorization_header = [
-          'Authorization',
+          "Authorization",
           ::Signet::OAuth1.generate_authorization_header(
             parameters, options[:realm]
           )
         ]
         headers = [authorization_header]
-        headers << ['Cache-Control', 'no-store']
+        headers << ["Cache-Control", "no-store"]
         if method == :post
-          headers << ['Content-Type', 'application/x-www-form-urlencoded']
-          headers << ['Content-Length', '0']
+          headers << ["Content-Type", "application/x-www-form-urlencoded"]
+          headers << ["Content-Length", "0"]
         end
-        return options[:connection].build_request(method.to_s.downcase.to_sym) do |req|
+        options[:connection].build_request method.to_s.downcase.to_sym do |req|
           req.url(Addressable::URI.parse(
-            self.token_credential_uri.to_str
+            token_credential_uri.to_str
           ).normalize.to_s)
-          req.headers = Faraday::Utils::Headers.new(headers)
+          req.headers = Faraday::Utils::Headers.new headers
         end
       end
-      alias_method(
-        :generate_access_token_request,
-        :generate_token_credential_request
-      )
+      # rubocop:enable Metrics/MethodLength
+      alias generate_access_token_request generate_token_credential_request
 
       ##
       # Transmits a request for a token credential.  This method does not
@@ -819,36 +801,25 @@ module Signet
       #   token_credential = client.fetch_token_credential(
       #     :verifier => '12345'
       #   )
-      def fetch_token_credential(options={})
+      def fetch_token_credential options = {}
         options[:connection] ||= Faraday.default_connection
-        request = self.generate_token_credential_request(options)
-        request_env = request.to_env(options[:connection])
+        request = generate_token_credential_request options
+        request_env = request.to_env options[:connection]
         request_env[:request] ||= request
-        response = options[:connection].app.call(request_env)
-        if response.status.to_i == 200
-          return ::Signet::OAuth1.parse_form_encoded_credentials(response.body)
-        elsif [400, 401, 403].include?(response.status.to_i)
-          message = 'Authorization failed.'
-          if response.body.to_s.strip.length > 0
-            message += "  Server message:\n#{response.body.to_s.strip}"
-          end
-          raise ::Signet::AuthorizationError.new(
-            message, :request => request, :response => response
-          )
-        else
-          message = "Unexpected status code: #{response.status}."
-          if response.body.to_s.strip.length > 0
-            message += "  Server message:\n#{response.body.to_s.strip}"
-          end
-          raise ::Signet::AuthorizationError.new(
-            message, :request => request, :response => response
-          )
-        end
+        response = options[:connection].app.call request_env
+        return ::Signet::OAuth1.parse_form_encoded_credentials response.body if response.status.to_i == 200
+        message = if [400, 401, 403].include? response.status.to_i
+                    "Authorization failed."
+                  else
+                    "Unexpected status code: #{response.status}."
+                  end
+        message += "  Server message:\n#{response.body.to_s.strip}" unless response.body.to_s.strip.empty?
+        raise ::Signet::AuthorizationError.new(
+          message, request: request, response: response
+        )
       end
-      alias_method(
-        :fetch_access_token,
-        :fetch_token_credential
-      )
+      # rubocop:enable Metrics/AbcSize
+      alias fetch_access_token fetch_token_credential
 
       ##
       # Transmits a request for a token credential.  This method updates
@@ -870,14 +841,15 @@ module Signet
       #
       # @example
       #   client.fetch_token_credential!(:verifier => '12345')
-      def fetch_token_credential!(options={})
-        credential = self.fetch_token_credential(options)
+      def fetch_token_credential! options = {}
+        credential = fetch_token_credential options
         self.token_credential = credential
       end
-      alias_method(
-        :fetch_access_token!,
-        :fetch_token_credential!
-      )
+      alias fetch_access_token! fetch_token_credential!
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
 
       ##
       # Generates an authenticated request for protected resources.
@@ -900,91 +872,85 @@ module Signet
       #     The Authorization realm.  See RFC 2617.
       #
       # @return [Array] The request object.
-      def generate_authenticated_request(options={})
+      def generate_authenticated_request options = {}
         verifications = {
-          :client_credential_key => 'Client credential key',
-          :client_credential_secret => 'Client credential secret'
+          client_credential_key:    "Client credential key",
+          client_credential_secret: "Client credential secret"
         }
-        unless self.two_legged
+        unless two_legged
           verifications.update(
-            :token_credential_key => 'Token credential key',
-            :token_credential_secret => 'Token credential secret'
+            token_credential_key:    "Token credential key",
+            token_credential_secret: "Token credential secret"
           )
         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
         options = {
-          :signature_method => 'HMAC-SHA1',
-          :realm => nil,
-          :connection => Faraday.default_connection
+          signature_method: "HMAC-SHA1",
+          realm:            nil,
+          connection:       Faraday.default_connection
         }.merge(options)
 
-        if options[:request].kind_of?(Faraday::Request)
+        if options[:request].is_a? Faraday::Request
           request = options[:request]
         else
-          if options[:request].kind_of?(Array)
+          if options[:request].is_a? Array
             method, uri, headers, body = options[:request]
           else
             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
           request_components = {
-            :method => method,
-            :uri => uri,
-            :headers => headers,
-            :body => body
+            method:  method,
+            uri:     uri,
+            headers: headers,
+            body:    body
           }
           # Verify that we have all pieces required to return an HTTP request
           request_components.each do |(key, value)|
-            unless value
-              raise ArgumentError, "Missing :#{key} parameter."
-            end
+            raise ArgumentError, "Missing :#{key} parameter." unless value
           end
-          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
           method = method.to_s.downcase.to_sym
-          request = options[:connection].build_request(method) do |req|
-            req.url(Addressable::URI.parse(uri).normalize.to_s)
-            req.headers = Faraday::Utils::Headers.new(headers)
+          request = options[:connection].build_request method do |req|
+            req.url Addressable::URI.parse(uri).normalize.to_s
+            req.headers = Faraday::Utils::Headers.new headers
             req.body = body
           end
         end
 
         parameters = ::Signet::OAuth1.unsigned_resource_parameters(
-          :client_credential_key => self.client_credential_key,
-          :token_credential_key => self.token_credential_key,
-          :signature_method => options[:signature_method],
-          :two_legged => self.two_legged
+          client_credential_key: client_credential_key,
+          token_credential_key:  token_credential_key,
+          signature_method:      options[:signature_method],
+          two_legged:            two_legged
         )
 
-        env = request.to_env(options[:connection])
+        env = request.to_env options[:connection]
 
-        content_type = request['Content-Type'].to_s
-        content_type = content_type.split(';', 2).first if content_type.index(';')
-        if request.method == :post && content_type == 'application/x-www-form-urlencoded'
+        content_type = request["Content-Type"].to_s
+        content_type = content_type.split(";", 2).first if content_type.index ";"
+        if request.method == :post && content_type == "application/x-www-form-urlencoded"
           # Serializes the body in case a hash/array was passed. Noop if already string like
-          encoder = Faraday::Request::UrlEncoded.new(lambda { |_env| })
-          encoder.call(env)
+          encoder = Faraday::Request::UrlEncoded.new(->(_env) {})
+          encoder.call env
           request.body = env[:body]
 
-          post_parameters = Addressable::URI.form_unencode(env[:body])
-          parameters = parameters.concat(post_parameters)
+          post_parameters = Addressable::URI.form_unencode env[:body]
+          parameters = parameters.concat post_parameters
         end
 
         # No need to attach URI query parameters, the .sign_parameters
@@ -993,16 +959,21 @@ module Signet
           env[:method],
           env[:url],
           parameters,
-          self.client_credential_secret,
-          self.token_credential_secret
+          client_credential_secret,
+          token_credential_secret
         )
 
-        parameters << ['oauth_signature', signature]
-        request['Authorization'] =  ::Signet::OAuth1.generate_authorization_header(
-            parameters, options[:realm])
-        request['Cache-Control'] = 'no-store'
-        return request
+        parameters << ["oauth_signature", signature]
+        request["Authorization"] = ::Signet::OAuth1.generate_authorization_header(
+          parameters, options[:realm]
+        )
+        request["Cache-Control"] = "no-store"
+        request
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
 
       ##
       # Transmits a request for a protected resource.
@@ -1043,25 +1014,20 @@ module Signet
       #   )
       #
       # @return [Array] The response object.
-      def fetch_protected_resource(options={})
+      def fetch_protected_resource options = {}
         options[:connection] ||= Faraday.default_connection
-        request = self.generate_authenticated_request(options)
-        request_env = request.to_env(options[:connection])
+        request = generate_authenticated_request options
+        request_env = request.to_env options[:connection]
         request_env[:request] ||= request
-        response = options[:connection].app.call(request_env)
-        if response.status.to_i == 401
-          # When accessing a protected resource, we only want to raise an
-          # error for 401 responses.
-          message = 'Authorization failed.'
-          if response.body.to_s.strip.length > 0
-            message += "  Server message:\n#{response.body.to_s.strip}"
-          end
-          raise ::Signet::AuthorizationError.new(
-            message, :request => request, :response => response
-          )
-        else
-          return response
-        end
+        response = options[:connection].app.call request_env
+        return response unless response.status.to_i == 401
+        # When accessing a protected resource, we only want to raise an
+        # error for 401 responses.
+        message = "Authorization failed."
+        message += "  Server message:\n#{response.body.to_s.strip}" unless response.body.to_s.strip.empty?
+        raise ::Signet::AuthorizationError.new(
+          message, request: request, response: response
+        )
       end
     end
   end