activemerchant 1.130.0 → 1.137.0

data/lib/active_merchant/billing/gateways/sage_pay.rb

@@ -6,8 +6,8 @@ module ActiveMerchant #:nodoc:
 
       class_attribute :simulator_url
 
-      self.test_url = 'https://test.sagepay.com/gateway/service'
-      self.live_url = 'https://live.sagepay.com/gateway/service'
+      self.test_url = 'https://sandbox.opayo.eu.elavon.com/gateway/service'
+      self.live_url = 'https://live.opayo.eu.elavon.com/gateway/service'
       self.simulator_url = 'https://test.sagepay.com/Simulator'
 
       APPROVED = 'OK'
@@ -78,6 +78,7 @@ module ActiveMerchant #:nodoc:
 
       def initialize(options = {})
         requires!(options, :login)
+        @protocol_version = options.fetch(:protocol_version, '3.00')
         super
       end
 
@@ -86,6 +87,9 @@ module ActiveMerchant #:nodoc:
 
         post = {}
 
+        add_override_protocol_version(options)
+        add_three_ds_data(post, options)
+        add_stored_credentials_data(post, options)
         add_amount(post, money, options)
         add_invoice(post, options)
         add_payment_method(post, payment_method, options)
@@ -101,6 +105,9 @@ module ActiveMerchant #:nodoc:
 
         post = {}
 
+        add_three_ds_data(post, options)
+        add_stored_credentials_data(post, options)
+        add_override_protocol_version(options)
         add_amount(post, money, options)
         add_invoice(post, options)
         add_payment_method(post, payment_method, options)
@@ -115,6 +122,7 @@ module ActiveMerchant #:nodoc:
       def capture(money, identification, options = {})
         post = {}
 
+        add_override_protocol_version(options)
         add_reference(post, identification)
         add_release_amount(post, money, options)
 
@@ -124,6 +132,7 @@ module ActiveMerchant #:nodoc:
       def void(identification, options = {})
         post = {}
 
+        add_override_protocol_version(options)
         add_reference(post, identification)
         action = abort_or_void_from(identification)
 
@@ -136,6 +145,7 @@ module ActiveMerchant #:nodoc:
 
         post = {}
 
+        add_override_protocol_version(options)
         add_related_reference(post, identification)
         add_amount(post, money, options)
         add_invoice(post, options)
@@ -150,6 +160,7 @@ module ActiveMerchant #:nodoc:
 
       def store(credit_card, options = {})
         post = {}
+        add_override_protocol_version(options)
         add_credit_card(post, credit_card)
         add_currency(post, 0, options)
 
@@ -158,6 +169,7 @@ module ActiveMerchant #:nodoc:
 
       def unstore(token, options = {})
         post = {}
+        add_override_protocol_version(options)
         add_token(post, token)
         commit(:unstore, post)
       end
@@ -182,6 +194,58 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def add_override_protocol_version(options)
+        @protocol_version = options[:protocol_version] if options[:protocol_version]
+      end
+
+      def add_three_ds_data(post, options)
+        return unless @protocol_version == '4.00'
+        return unless three_ds_2_options = options[:three_ds_2]
+
+        add_pair(post, :ThreeDSNotificationURL, three_ds_2_options[:notification_url])
+        return unless three_ds_2_options[:browser_info]
+
+        add_browser_info(post, three_ds_2_options[:browser_info])
+      end
+
+      def add_browser_info(post, browser_info)
+        add_pair(post, :BrowserAcceptHeader, browser_info[:accept_header])
+        add_pair(post, :BrowserColorDepth, browser_info[:depth])
+        add_pair(post, :BrowserJavascriptEnabled, format_boolean(browser_info[:java]))
+        add_pair(post, :BrowserJavaEnabled, format_boolean(browser_info[:java]))
+        add_pair(post, :BrowserLanguage, browser_info[:language])
+        add_pair(post, :BrowserScreenHeight, browser_info[:height])
+        add_pair(post, :BrowserScreenWidth, browser_info[:width])
+        add_pair(post, :BrowserTZ, browser_info[:timezone])
+        add_pair(post, :BrowserUserAgent, browser_info[:user_agent])
+        add_pair(post, :ChallengeWindowSize, browser_info[:browser_size])
+      end
+
+      def add_stored_credentials_data(post, options)
+        return unless @protocol_version == '4.00'
+        return unless stored_credential = options[:stored_credential]
+
+        initiator = stored_credential[:initiator] == 'cardholder' ? 'CIT' : 'MIT'
+        cof_usage = if stored_credential[:initial_transaction] && initiator == 'CIT'
+                      'FIRST'
+                    elsif !stored_credential[:initial_transaction] && initiator == 'MIT'
+                      'SUBSEQUENT'
+                    end
+
+        add_pair(post, :COFUsage, cof_usage) if cof_usage
+        add_pair(post, :InitiatedTYPE, initiator)
+        add_pair(post, :SchemeTraceID, stored_credential[:network_transaction_id]) if stored_credential[:network_transaction_id]
+
+        reasoning = stored_credential[:reason_type] == 'installment' ? 'instalment' : stored_credential[:reason_type]
+        add_pair(post, :MITType, reasoning.upcase)
+
+        if %w(instalment recurring).any?(reasoning)
+          add_pair(post, :RecurringExpiry, options[:recurring_expiry])
+          add_pair(post, :RecurringFrequency, options[:recurring_frequency])
+          add_pair(post, :PurchaseInstalData, options[:installment_data])
+        end
+      end
+
       def truncate(value, max_size)
         return nil unless value
         return value.to_s if CGI.escape(value.to_s).length <= max_size
@@ -346,14 +410,18 @@ module ActiveMerchant #:nodoc:
       def commit(action, parameters)
         response = parse(ssl_post(url_for(action), post_data(action, parameters)))
 
-        Response.new(response['Status'] == APPROVED, message_from(response), response,
+        Response.new(
+          response['Status'] == APPROVED,
+          message_from(response),
+          response,
           test: test?,
           authorization: authorization_from(response, parameters, action),
           avs_result: {
             street_match: AVS_CODE[response['AddressResult']],
             postal_match: AVS_CODE[response['PostCodeResult']]
           },
-          cvv_result: CVV_CODE[response['CV2Result']])
+          cvv_result: CVV_CODE[response['CV2Result']]
+        )
       end
 
       def authorization_from(response, params, action)
@@ -401,7 +469,7 @@ module ActiveMerchant #:nodoc:
         parameters.update(
           Vendor: @options[:login],
           TxType: TRANSACTIONS[action],
-          VPSProtocol: @options.fetch(:protocol_version, '3.00')
+          VPSProtocol: @protocol_version
         )
 
         parameters.update(ReferrerID: application_id) if application_id && (application_id != Gateway.application_id)
@@ -409,6 +477,12 @@ module ActiveMerchant #:nodoc:
         parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
+      def format_boolean(value)
+        return if value.nil?
+
+        value ? '1' : '0'
+      end
+
       # SagePay returns data in the following format
       # Key1=value1
       # Key2=value2

data/lib/active_merchant/billing/gateways/sallie_mae.rb

@@ -120,9 +120,13 @@ module ActiveMerchant #:nodoc:
         end
 
         response = parse(ssl_post(self.live_url, parameters.to_post_data) || '')
-        Response.new(successful?(response), message_from(response), response,
+        Response.new(
+          successful?(response),
+          message_from(response),
+          response,
           test: test?,
-          authorization: response['refcode'])
+          authorization: response['refcode']
+        )
       end
 
       def successful?(response)

data/lib/active_merchant/billing/gateways/secure_net.rb

@@ -79,11 +79,15 @@ module ActiveMerchant #:nodoc:
         data = ssl_post(url, xml, 'Content-Type' => 'text/xml')
         response = parse(data)
 
-        Response.new(success?(response), message_from(response), response,
+        Response.new(
+          success?(response),
+          message_from(response),
+          response,
           test: test?,
           authorization: build_authorization(response),
           avs_result: { code: response[:avs_result_code] },
-          cvv_result: response[:card_code_response_code])
+          cvv_result: response[:card_code_response_code]
+        )
       end
 
       def build_request(request)

data/lib/active_merchant/billing/gateways/secure_pay.rb

@@ -56,12 +56,16 @@ module ActiveMerchant #:nodoc:
 
         message = message_from(response)
 
-        Response.new(success?(response), message, response,
+        Response.new(
+          success?(response),
+          message,
+          response,
           test: test?,
           authorization: response[:transaction_id],
           fraud_review: fraud_review?(response),
           avs_result: { code: response[:avs_result_code] },
-          cvv_result: response[:card_code])
+          cvv_result: response[:card_code]
+        )
       end
 
       def success?(response)
@@ -75,7 +79,7 @@ module ActiveMerchant #:nodoc:
       def parse(body)
         fields = split(body)
 
-        results = {
+        {
           response_code: fields[RESPONSE_CODE].to_i,
           response_reason_code: fields[RESPONSE_REASON_CODE],
           response_reason_text: fields[RESPONSE_REASON_TEXT],
@@ -85,7 +89,6 @@ module ActiveMerchant #:nodoc:
           authorization_code: fields[AUTHORIZATION_CODE],
           cardholder_authentication_code: fields[CARDHOLDER_AUTH_CODE]
         }
-        results
       end
 
       def post_data(action, parameters = {})
@@ -101,8 +104,7 @@ module ActiveMerchant #:nodoc:
         post[:encap_char]     = '$'
         post[:solution_ID]    = application_id if application_id
 
-        request = post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
-        request
+        post.merge(parameters).collect { |key, value| "x_#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def add_currency_code(post, money, options)

data/lib/active_merchant/billing/gateways/secure_pay_au.rb

@@ -183,9 +183,13 @@ module ActiveMerchant #:nodoc:
       def commit(action, request)
         response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(action, request)))
 
-        Response.new(success?(response), message_from(response), response,
+        Response.new(
+          success?(response),
+          message_from(response),
+          response,
           test: test?,
-          authorization: authorization_from(response))
+          authorization: authorization_from(response)
+        )
       end
 
       def build_periodic_item(action, money, credit_card, options)
@@ -239,9 +243,13 @@ module ActiveMerchant #:nodoc:
         my_request = build_periodic_request(request)
         response = parse(ssl_post(test? ? self.test_periodic_url : self.live_periodic_url, my_request))
 
-        Response.new(success?(response), message_from(response), response,
+        Response.new(
+          success?(response),
+          message_from(response),
+          response,
           test: test?,
-          authorization: authorization_from(response))
+          authorization: authorization_from(response)
+        )
       end
 
       def success?(response)

data/lib/active_merchant/billing/gateways/secure_pay_tech.rb

@@ -84,9 +84,13 @@ module ActiveMerchant #:nodoc:
       def commit(action, post)
         response = parse(ssl_post(self.live_url, post_data(action, post)))
 
-        Response.new(response[:result_code] == 1, message_from(response), response,
+        Response.new(
+          response[:result_code] == 1,
+          message_from(response),
+          response,
           test: test?,
-          authorization: response[:merchant_transaction_reference])
+          authorization: response[:merchant_transaction_reference]
+        )
       end
 
       def message_from(result)

data/lib/active_merchant/billing/gateways/securion_pay.rb

@@ -193,7 +193,8 @@ module ActiveMerchant #:nodoc:
           post[:card] = card
           add_address(post, options)
         elsif creditcard.kind_of?(String)
-          post[:card] = creditcard
+          key = creditcard.match(/^pm_/) ? :paymentMethod : :card
+          post[key] = creditcard
         else
           raise ArgumentError.new("Unhandled payment method #{creditcard.class}.")
         end
@@ -223,24 +224,37 @@ module ActiveMerchant #:nodoc:
         end
 
         response = api_request(url, parameters, options, method)
-        success = !response.key?('error')
+        success = success?(response)
 
-        Response.new(success,
+        Response.new(
+          success,
           (success ? 'Transaction approved' : response['error']['message']),
           response,
           test: test?,
-          authorization: (success ? response['id'] : response['error']['charge']),
-          error_code: (success ? nil : STANDARD_ERROR_CODE_MAPPING[response['error']['code']]))
+          authorization: authorization_from(url, response),
+          error_code: (success ? nil : STANDARD_ERROR_CODE_MAPPING[response['error']['code']])
+        )
+      end
+
+      def authorization_from(action, response)
+        if action == 'customers' && success?(response) && response['cards'].present?
+          response['cards'].first['id']
+        else
+          success?(response) ? response['id'] : (response.dig('error', 'charge') || response.dig('error', 'chargeId'))
+        end
+      end
+
+      def success?(response)
+        !response.key?('error')
       end
 
       def headers(options = {})
         secret_key = options[:secret_key] || @options[:secret_key]
 
-        headers = {
+        {
           'Authorization' => 'Basic ' + Base64.encode64(secret_key.to_s + ':').strip,
           'User-Agent' => "SecurionPay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
         }
-        headers
       end
 
       def response_error(raw_response)
@@ -287,8 +301,8 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      def json_error(raw_response)
-        msg = 'Invalid response received from the SecurionPay API.'
+      def json_error(raw_response, gateway_name = 'SecurionPay')
+        msg = "Invalid response received from the #{gateway_name} API."
         msg += "  (The raw response returned by the API was #{raw_response.inspect})"
         {
           'error' => {
@@ -298,7 +312,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def test?
-        (@options[:secret_key]&.include?('_test_'))
+        @options[:secret_key]&.include?('_test_')
       end
     end
   end

data/lib/active_merchant/billing/gateways/shift4.rb

@@ -20,22 +20,6 @@ module ActiveMerchant #:nodoc:
         'add' => 'tokens',
         'verify' => 'cards'
       }
-      STANDARD_ERROR_CODE_MAPPING = {
-        'incorrect_number' => STANDARD_ERROR_CODE[:incorrect_number],
-        'invalid_number' => STANDARD_ERROR_CODE[:invalid_number],
-        'invalid_expiry_month' => STANDARD_ERROR_CODE[:invalid_expiry_date],
-        'invalid_expiry_year' => STANDARD_ERROR_CODE[:invalid_expiry_date],
-        'invalid_cvc' => STANDARD_ERROR_CODE[:invalid_cvc],
-        'expired_card' => STANDARD_ERROR_CODE[:expired_card],
-        'insufficient_funds' => STANDARD_ERROR_CODE[:card_declined],
-        'incorrect_cvc' => STANDARD_ERROR_CODE[:incorrect_cvc],
-        'incorrect_zip' => STANDARD_ERROR_CODE[:incorrect_zip],
-        'card_declined' => STANDARD_ERROR_CODE[:card_declined],
-        'processing_error' => STANDARD_ERROR_CODE[:processing_error],
-        'lost_or_stolen' => STANDARD_ERROR_CODE[:card_declined],
-        'suspected_fraud' => STANDARD_ERROR_CODE[:card_declined],
-        'expired_token' => STANDARD_ERROR_CODE[:card_declined]
-      }
 
       def initialize(options = {})
         requires!(options, :client_guid, :auth_token)
@@ -147,7 +131,7 @@ module ActiveMerchant #:nodoc:
           gsub(%r(("expirationDate\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
           gsub(%r(("FirstName\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
           gsub(%r(("LastName\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
-          gsub(%r(("securityCode\\?":{\\?"[\w]+\\?":[\d]+,\\?"value\\?":\\?")[\d]*)i, '\1[FILTERED]')
+          gsub(%r(("securityCode\\?":{\\?"\w+\\?":\d+,\\?"value\\?":\\?")\d*)i, '\1[FILTERED]')
       end
 
       def setup_access_token
@@ -263,6 +247,7 @@ module ActiveMerchant #:nodoc:
           message_from(action, response),
           response,
           authorization: authorization_from(action, response),
+          avs_result: avs_result_from(response),
           test: test?,
           error_code: error_code_from(action, response)
         )
@@ -284,13 +269,25 @@ module ActiveMerchant #:nodoc:
       end
 
       def message_from(action, response)
-        success_from(action, response) ? 'Transaction successful' : (error(response)&.dig('longText') || 'Transaction declined')
+        success_from(action, response) ? 'Transaction successful' : (error(response)&.dig('longText') || response['result'].first&.dig('transaction', 'hostResponse', 'reasonDescription') || 'Transaction declined')
       end
 
       def error_code_from(action, response)
-        return unless success_from(action, response)
+        code = response['result'].first&.dig('transaction', 'responseCode')
+        primary_code = response['result'].first['error'].present?
+        return unless code == 'D' || primary_code == true || success_from(action, response)
+
+        if response['result'].first&.dig('transaction', 'hostResponse')
+          response['result'].first&.dig('transaction', 'hostResponse', 'reasonCode')
+        elsif response['result'].first['error']
+          response['result'].first&.dig('error', 'primaryCode')
+        else
+          response['result'].first&.dig('transaction', 'responseCode')
+        end
+      end
 
-        STANDARD_ERROR_CODE_MAPPING[response['primaryCode']]
+      def avs_result_from(response)
+        AVSResult.new(code: response['result'].first&.dig('transaction', 'avs', 'result')) if response['result'].first&.dig('transaction', 'avs')
       end
 
       def authorization_from(action, response)

data/lib/active_merchant/billing/gateways/shift4_v2.rb

@@ -0,0 +1,117 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class Shift4V2Gateway < SecurionPayGateway
+      # same endpont for testing
+      self.live_url = 'https://api.shift4.com/'
+      self.display_name = 'Shift4'
+      self.homepage_url = 'https://dev.shift4.com/us/'
+
+      def credit(money, payment, options = {})
+        post = create_post_for_auth_or_purchase(money, payment, options)
+        commit('credits', post, options)
+      end
+
+      def store(payment_method, options = {})
+        post = case payment_method
+               when CreditCard
+                 cc = {}.tap { |card| add_creditcard(card, payment_method, options) }[:card]
+                 options[:customer_id].blank? ? { email: options[:email], card: cc } : cc
+               when Check
+                 bank_account_object(payment_method, options)
+               else
+                 raise ArgumentError.new("Unhandled payment method #{payment_method.class}.")
+               end
+
+        commit url_for_store(payment_method, options), post, options
+      end
+
+      def url_for_store(payment_method, options = {})
+        case payment_method
+        when CreditCard
+          options[:customer_id].blank? ? 'customers' : "customers/#{options[:customer_id]}/cards"
+        when Check then 'payment-methods'
+        end
+      end
+
+      def unstore(reference, options = {})
+        commit("customers/#{options[:customer_id]}/cards/#{reference}", nil, options, :delete)
+      end
+
+      def create_post_for_auth_or_purchase(money, payment, options)
+        super.tap do |post|
+          add_stored_credentials(post, options)
+        end
+      end
+
+      def add_stored_credentials(post, options)
+        return unless options[:stored_credential].present?
+
+        initiator = options.dig(:stored_credential, :initiator)
+        reason_type = options.dig(:stored_credential, :reason_type)
+
+        post_type = {
+          %w[cardholder recurring] => 'first_recurring',
+          %w[merchant recurring] => 'subsequent_recurring',
+          %w[cardholder unscheduled] => 'customer_initiated',
+          %w[merchant installment] => 'merchant_initiated'
+        }[[initiator, reason_type]]
+        post[:type] = post_type if post_type
+      end
+
+      def headers(options = {})
+        super.tap do |headers|
+          headers['User-Agent'] = "Shift4/v2 ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+        end
+      end
+
+      def scrub(transcript)
+        super.
+          gsub(%r((card\[expMonth\]=)\d+), '\1[FILTERED]').
+          gsub(%r((card\[expYear\]=)\d+), '\1[FILTERED]').
+          gsub(%r((card\[cardholderName\]=)\w+[^ ]\w+), '\1[FILTERED]')
+      end
+
+      def json_error(raw_response)
+        super(raw_response, 'Shift4 V2')
+      end
+
+      def add_amount(post, money, options, include_currency = false)
+        super
+        post[:currency]&.upcase!
+      end
+
+      def add_creditcard(post, payment_method, options)
+        return super unless payment_method.is_a?(Check)
+
+        post[:paymentMethod] = bank_account_object(payment_method, options)
+      end
+
+      def bank_account_object(payment_method, options)
+        {
+          type: :ach,
+          fraudCheckData: {
+            ipAddress: options[:ip],
+            email: options[:email]
+          }.compact,
+          billing: {
+            name: payment_method.name,
+            address: { country: options.dig(:billing_address, :country) }
+          }.compact,
+          ach: {
+            account: {
+              routingNumber: payment_method.routing_number,
+              accountNumber: payment_method.account_number,
+              accountType: get_account_type(payment_method)
+            },
+            verificationProvider: :external
+          }
+        }
+      end
+
+      def get_account_type(check)
+        holder = (check.account_holder_type || '').match(/business/i) ? :corporate : :personal
+        "#{holder}_#{check.account_type}"
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/simetrik.rb

@@ -44,7 +44,7 @@ module ActiveMerchant #:nodoc:
       def initialize(options = {})
         requires!(options, :client_id, :client_secret)
         super
-        @access_token = {}
+        @access_token = options[:access_token] || {}
         sign_access_token()
       end
 
@@ -280,12 +280,12 @@ module ActiveMerchant #:nodoc:
       def commit(action, parameters, url_params = {})
         begin
           response = JSON.parse ssl_post(url(action, url_params), post_data(parameters), authorized_headers())
-        rescue ResponseError => exception
-          case exception.response.code.to_i
+        rescue ResponseError => e
+          case e.response.code.to_i
           when 400...499
-            response = JSON.parse exception.response.body
+            response = JSON.parse e.response.body
           else
-            raise exception
+            raise e
           end
         end
 
@@ -318,7 +318,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def url(action, url_params)
-        "#{(test? ? test_url : live_url)}/#{url_params[:token_acquirer]}/#{action}"
+        "#{test? ? test_url : live_url}/#{url_params[:token_acquirer]}/#{action}"
       end
 
       def post_data(data = {})
@@ -356,12 +356,18 @@ module ActiveMerchant #:nodoc:
         login_info[:client_secret] = @options[:client_secret]
         login_info[:audience] = test? ? test_audience : live_audience
         login_info[:grant_type] = 'client_credentials'
-        response = parse(ssl_post(auth_url(), login_info.to_json, {
-          'content-Type' => 'application/json'
-        }))
 
-        @access_token[:access_token] = response['access_token']
-        @access_token[:expires_at] = Time.new.to_i + response['expires_in']
+        begin
+          raw_response = ssl_post(auth_url(), login_info.to_json, {
+            'content-Type' => 'application/json'
+          })
+        rescue ResponseError => e
+          raise OAuthResponseError.new(e)
+        else
+          response = parse(raw_response)
+          @access_token[:access_token] = response['access_token']
+          @access_token[:expires_at] = Time.new.to_i + response['expires_in']
+        end
       end
     end
   end

data/lib/active_merchant/billing/gateways/skip_jack.rb

@@ -263,11 +263,15 @@ module ActiveMerchant #:nodoc:
         response = parse(ssl_post(url_for(action), post_data(action, money, parameters)), action)
 
         # Pass along the original transaction id in the case an update transaction
-        Response.new(response[:success], message_from(response, action), response,
+        Response.new(
+          response[:success],
+          message_from(response, action),
+          response,
           test: test?,
           authorization: response[:szTransactionFileName] || parameters[:szTransactionId],
           avs_result: { code: response[:szAVSResponseCode] },
-          cvv_result: response[:szCVV2ResponseCode])
+          cvv_result: response[:szCVV2ResponseCode]
+        )
       end
 
       def url_for(action)

data/lib/active_merchant/billing/gateways/smart_ps.rb

@@ -226,11 +226,15 @@ module ActiveMerchant #:nodoc:
       def commit(action, money, parameters)
         parameters[:amount] = localized_amount(money, parameters[:currency] || default_currency) if money
         response = parse(ssl_post(self.live_url, post_data(action, parameters)))
-        Response.new(response['response'] == '1', message_from(response), response,
+        Response.new(
+          response['response'] == '1',
+          message_from(response),
+          response,
           authorization: (response['transactionid'] || response['customer_vault_id']),
           test: test?,
           cvv_result: response['cvvresponse'],
-          avs_result: { code: response['avsresponse'] })
+          avs_result: { code: response['avsresponse'] }
+        )
       end
 
       def expdate(creditcard)
@@ -257,8 +261,7 @@ module ActiveMerchant #:nodoc:
         post[:password]   = @options[:password]
         post[:type]       = action if action
 
-        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
-        request
+        post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def determine_funding_source(source)