activemerchant 1.133.0 → 1.138.0

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

@@ -1,8 +1,10 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CommerceHubGateway < Gateway
-      self.test_url = 'https://cert.api.fiservapps.com/ch'
-      self.live_url = 'https://prod.api.fiservapps.com/ch'
+      version 'v1'
+
+      self.test_url = 'https://connect-cert.fiservapps.com/ch'
+      self.live_url = 'https://connect.fiservapis.com/ch'
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
@@ -15,11 +17,11 @@ module ActiveMerchant #:nodoc:
 
       SCHEDULED_REASON_TYPES = %w(recurring installment)
       ENDPOINTS = {
-        'sale' => '/payments/v1/charges',
-        'void' => '/payments/v1/cancels',
-        'refund' => '/payments/v1/refunds',
-        'vault' => '/payments-vas/v1/tokens',
-        'verify' => '/payments-vas/v1/accounts/verification'
+        'sale' => "/payments/#{fetch_version}/charges",
+        'void' => "/payments/#{fetch_version}/cancels",
+        'refund' => "/payments/#{fetch_version}/refunds",
+        'vault' => "/payments-vas/#{fetch_version}/tokens",
+        'verify' => "/payments-vas/#{fetch_version}/accounts/verification"
       }
 
       def initialize(options = {})
@@ -55,6 +57,7 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, money, options)
         add_transaction_details(post, options, 'capture')
         add_reference_transaction_details(post, authorization, options, :capture)
+        add_dynamic_descriptors(post, options)
 
         commit('sale', post, options)
       end
@@ -68,6 +71,16 @@ module ActiveMerchant #:nodoc:
         commit('refund', post, options)
       end
 
+      def credit(money, payment_method, options = {})
+        post = {}
+        add_invoice(post, money, options)
+        add_transaction_details(post, options)
+        add_transaction_interaction(post, options)
+        add_payment(post, payment_method, options)
+
+        commit('refund', post, options)
+      end
+
       def void(authorization, options = {})
         post = {}
         add_transaction_details(post, options)
@@ -90,6 +103,7 @@ module ActiveMerchant #:nodoc:
         post = {}
         add_payment(post, credit_card, options)
         add_billing_address(post, credit_card, options)
+        add_transaction_details(post, options, 'verify')
 
         commit('verify', post, options)
       end
@@ -102,6 +116,7 @@ module ActiveMerchant #:nodoc:
         transcript.
           gsub(%r((Authorization: )[a-zA-Z0-9+./=]+), '\1[FILTERED]').
           gsub(%r((Api-Key: )\w+), '\1[FILTERED]').
+          gsub(%r(("apiKey\\?":\\?")\w+), '\1[FILTERED]').
           gsub(%r(("cardData\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r(("securityCode\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r(("cavv\\?":\\?")\w+), '\1[FILTERED]')
@@ -109,10 +124,27 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def add_three_d_secure(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:additionalData3DS] = {
+          dsTransactionId: three_d_secure[:ds_transaction_id],
+          authenticationStatus: three_d_secure[:authentication_response_status],
+          serverTransactionId: three_d_secure[:three_ds_server_trans_id],
+          acsTransactionId: three_d_secure[:acs_transaction_id],
+          mpiData: {
+            cavv: three_d_secure[:cavv],
+            eci: three_d_secure[:eci],
+            xid: three_d_secure[:xid]
+          }.compact,
+          versionData: { recommendedVersion: three_d_secure[:version] }
+        }.compact
+      end
+
       def add_transaction_interaction(post, options)
         post[:transactionInteraction] = {}
         post[:transactionInteraction][:origin] = options[:origin] || 'ECOM'
-        post[:transactionInteraction][:eciIndicator] = options[:eci_indicator] || 'CHANNEL_ENCRYPTED'
+        post[:transactionInteraction][:eciIndicator] = map_ecommerce_indicator(options)
         post[:transactionInteraction][:posConditionCode] = options[:pos_condition_code] || 'CARD_NOT_PRESENT_ECOM'
         post[:transactionInteraction][:posEntryMode] = (options[:pos_entry_mode] || 'MANUAL') unless options[:encryption_data].present?
         post[:transactionInteraction][:additionalPosInformation] = {}
@@ -126,16 +158,12 @@ module ActiveMerchant #:nodoc:
           physicalGoodsIndicator: [true, 'true'].include?(options[:physical_goods_indicator])
         }
 
-        if options[:order_id].present? && action == 'sale'
+        if %w(sale verify).include?(action)
           details[:merchantOrderId] = options[:order_id]
-          details[:merchantTransactionId] = options[:order_id]
+          details[:merchantTransactionId] = rand.to_s[2..13]
         end
 
-        if action != 'capture'
-          details[:merchantInvoiceNumber] = options[:merchant_invoice_number] || rand.to_s[2..13]
-          details[:primaryTransactionType] = options[:primary_transaction_type]
-          details[:accountVerification] = options[:account_verification]
-        end
+        details[:merchantInvoiceNumber] = options[:order_id] if action != 'capture'
 
         post[:transactionDetails] = details.compact
       end
@@ -144,10 +172,7 @@ module ActiveMerchant #:nodoc:
         return unless billing = options[:billing_address]
 
         billing_address = {}
-        if payment.is_a?(CreditCard)
-          billing_address[:firstName] = payment.first_name if payment.first_name
-          billing_address[:lastName] = payment.last_name if payment.last_name
-        end
+        name_from_address(billing_address, billing) || name_from_payment(billing_address, payment)
         address = {}
         address[:street] = billing[:address1] if billing[:address1]
         address[:houseNumberOrName] = billing[:address2] if billing[:address2]
@@ -165,6 +190,22 @@ module ActiveMerchant #:nodoc:
         post[:billingAddress] = billing_address
       end
 
+      def name_from_payment(billing_address, payment)
+        return unless payment.respond_to?(:first_name) && payment.respond_to?(:last_name)
+
+        billing_address[:firstName] = payment.first_name if payment.first_name
+        billing_address[:lastName] = payment.last_name if payment.last_name
+      end
+
+      def name_from_address(billing_address, billing)
+        return unless address = billing
+
+        first_name, last_name = split_names(address[:name]) if address[:name]
+
+        billing_address[:firstName] = first_name if first_name
+        billing_address[:lastName] = last_name if last_name
+      end
+
       def add_shipping_address(post, options)
         return unless shipping = options[:shipping_address]
 
@@ -187,12 +228,28 @@ module ActiveMerchant #:nodoc:
       end
 
       def build_purchase_and_auth_request(post, money, payment, options)
+        add_three_d_secure(post, options)
         add_invoice(post, money, options)
         add_payment(post, payment, options)
         add_stored_credentials(post, options)
         add_transaction_interaction(post, options)
         add_billing_address(post, payment, options)
         add_shipping_address(post, options)
+        add_dynamic_descriptors(post, options)
+      end
+
+      def add_dynamic_descriptors(post, options)
+        dynamic_descriptors_fields = %i[mcc merchant_name customer_service_number service_entitlement dynamic_descriptors_address]
+        return unless dynamic_descriptors_fields.any? { |key| options.include?(key) }
+
+        dynamic_descriptors = {}
+        dynamic_descriptors[:mcc] = options[:mcc] if options[:mcc]
+        dynamic_descriptors[:merchantName] = options[:merchant_name] if options[:merchant_name]
+        dynamic_descriptors[:customerServiceNumber] = options[:customer_service_number] if options[:customer_service_number]
+        dynamic_descriptors[:serviceEntitlement] = options[:service_entitlement] if options[:service_entitlement]
+        dynamic_descriptors[:address] = options[:dynamic_descriptors_address] if options[:dynamic_descriptors_address]
+
+        post[:dynamicDescriptors] = dynamic_descriptors
       end
 
       def add_reference_transaction_details(post, authorization, options, action = nil)
@@ -254,20 +311,31 @@ module ActiveMerchant #:nodoc:
         source[:walletType] = payment.source.to_s.upcase
       end
 
+      def add_network_token(source, payment, options)
+        source[:sourceType] = 'PaymentToken'
+        source[:tokenData] = payment.number
+        source[:tokenSource] = 'NETWORK_TOKEN'
+        source[:cryptogram] = payment.payment_cryptogram
+        source[:card] = {
+          expirationMonth: format(payment.month, :two_digits),
+          expirationYear: format(payment.year, :four_digits)
+        }
+      end
+
       def add_payment(post, payment, options = {})
         source = {}
-        case payment
-        when NetworkTokenizationCreditCard
-          add_decrypted_wallet(source, payment, options)
-        when CreditCard
-          if options[:encryption_data].present?
-            source[:sourceType] = 'PaymentCard'
-            source[:encryptionData] = options[:encryption_data]
-          else
-            add_credit_card(source, payment, options)
-          end
-        when String
+
+        if payment.is_a?(String)
           add_payment_token(source, payment, options)
+        elsif payment.mobile_wallet?
+          add_decrypted_wallet(source, payment, options)
+        elsif payment.network_token?
+          add_network_token(source, payment, options)
+        elsif options[:encryption_data].present?
+          source[:sourceType] = 'PaymentCard'
+          source[:encryptionData] = options[:encryption_data]
+        elsif payment.is_a?(CreditCard)
+          add_credit_card(source, payment, options)
         end
         post[:source] = source
       end
@@ -278,11 +346,11 @@ module ActiveMerchant #:nodoc:
 
       def headers(request, options)
         time = DateTime.now.strftime('%Q').to_s
-        client_request_id = options[:client_request_id] || rand.to_s[2..8]
+        client_request_id = options[:client_request_id] || SecureRandom.uuid
         raw_signature = @options[:api_key] + client_request_id.to_s + time + request
         hmac = OpenSSL::HMAC.digest('sha256', @options[:api_secret], raw_signature)
         signature = Base64.strict_encode64(hmac.to_s).to_s
-
+        custom_headers = options.fetch(:headers_identifiers, {})
         {
           'Client-Request-Id' => client_request_id,
           'Api-Key' => @options[:api_key],
@@ -292,7 +360,7 @@ module ActiveMerchant #:nodoc:
           'Content-Type' => 'application/json',
           'Accept' => 'application/json',
           'Authorization' => signature
-        }
+        }.merge!(custom_headers)
       end
 
       def add_merchant_details(post)
@@ -365,6 +433,20 @@ module ActiveMerchant #:nodoc:
       def error_code_from(response, action)
         response.dig('error', 0, 'code') unless success_from(response, action)
       end
+
+      def map_ecommerce_indicator(options)
+        return options[:eci_indicator] if options[:eci_indicator]
+        return 'CHANNEL_ENCRYPTED'     unless options[:three_d_secure]
+
+        case options[:three_d_secure][:eci]
+        when '2', '02', '5', '05'
+          'SECURE_ECOM'
+        when '01', '1', '06', '6'
+          'NON_AUTH_ECOM'
+        else
+          'CHANNEL_ENCRYPTED'
+        end
+      end
     end
   end
 end

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CommercegateGateway < Gateway
       self.test_url = self.live_url = 'https://secure.commercegate.com/gateway/nvp'
 
@@ -127,8 +127,8 @@ module ActiveMerchant #:nodoc:
           response['returnText']
         else
           'Invalid response received from the CommerceGate API. ' \
-          'Please contact CommerceGate support if you continue to receive this message. ' \
-          "(The raw response returned by the API was #{response.inspect})"
+            'Please contact CommerceGate support if you continue to receive this message. ' \
+            "(The raw response returned by the API was #{response.inspect})"
         end
       end
 

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class ConektaGateway < Gateway
       self.live_url = 'https://api.conekta.io/'
 

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CreditcallGateway < Gateway
       include Empty
 

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CredoraxGateway < Gateway
       class_attribute :test_url, :live_na_url, :live_eu_url
 
@@ -150,6 +150,12 @@ module ActiveMerchant #:nodoc:
         add_submerchant_id(post, options)
         add_stored_credential(post, options)
         add_processor(post, options)
+        add_crypto_currency_type(post, options)
+
+        if options[:aft]
+          add_recipient(post, options)
+          add_sender(post, options)
+        end
 
         commit(:purchase, post)
       end
@@ -165,8 +171,15 @@ module ActiveMerchant #:nodoc:
         add_echo(post, options)
         add_submerchant_id(post, options)
         add_stored_credential(post, options)
+        add_account_name_inquiry(post, options)
         add_processor(post, options)
         add_authorization_details(post, options)
+        add_crypto_currency_type(post, options)
+
+        if options[:aft]
+          add_recipient(post, options)
+          add_sender(post, options)
+        end
 
         commit(:authorize, post)
       end
@@ -179,6 +192,8 @@ module ActiveMerchant #:nodoc:
         add_echo(post, options)
         add_submerchant_id(post, options)
         add_processor(post, options)
+        add_crypto_currency_type(post, options)
+        add_transaction_type(post, options)
 
         commit(:capture, post)
       end
@@ -191,6 +206,8 @@ module ActiveMerchant #:nodoc:
         add_submerchant_id(post, options)
         post[:a1] = generate_unique_id
         add_processor(post, options)
+        add_crypto_currency_type(post, options)
+        add_transaction_type(post, options)
 
         commit(:void, post, reference_action)
       end
@@ -205,6 +222,8 @@ module ActiveMerchant #:nodoc:
         add_processor(post, options)
         add_email(post, options)
         add_recipient(post, options)
+        add_crypto_currency_type(post, options)
+        add_transaction_type(post, options)
 
         if options[:referral_cft]
           add_customer_name(post, options)
@@ -225,14 +244,16 @@ module ActiveMerchant #:nodoc:
         add_transaction_type(post, options)
         add_processor(post, options)
         add_customer_name(post, options)
+        add_crypto_currency_type(post, options)
 
         commit(:credit, post)
       end
 
-      def verify(credit_card, options = {})
+      def verify(payment_method, options = {})
+        amount = eligible_for_0_auth?(payment_method, options) ? 0 : 100
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
-          r.process(:ignore_result) { void(r.authorization, options) }
+          r.process { authorize(amount, payment_method, options) }
+          r.process(:ignore_result) { void(r.authorization, options) } unless eligible_for_0_auth?(payment_method, options)
         end
       end
 
@@ -254,9 +275,7 @@ module ActiveMerchant #:nodoc:
             normalized_value = normalize(value)
             next if normalized_value.nil?
 
-            if key == :'3ds_homephonecountry'
-              next unless options[:billing_address] && options[:billing_address][:phone]
-            end
+            next if key == :'3ds_homephonecountry' && !(options[:billing_address] && options[:billing_address][:phone])
 
             post[key] = normalized_value unless post[key]
           end
@@ -284,7 +303,7 @@ module ActiveMerchant #:nodoc:
       }
 
       def add_payment_method(post, payment_method, options)
-        post[:c1] = payment_method&.name || ''
+        post[:c1] = payment_method&.name || '' unless options[:account_name_inquiry].to_s == 'true'
         add_network_tokenization_card(post, payment_method, options) if payment_method.is_a? NetworkTokenizationCreditCard
         post[:b2] = CARD_TYPES[payment_method.brand] || ''
         post[:b1] = payment_method.number
@@ -293,6 +312,10 @@ module ActiveMerchant #:nodoc:
         post[:b3] = format(payment_method.month, :two_digits)
       end
 
+      def eligible_for_0_auth?(payment_method, options = {})
+        payment_method.is_a?(CreditCard) && %w(visa master).include?(payment_method.brand) && options[:zero_dollar_auth]
+      end
+
       def add_network_tokenization_card(post, payment_method, options)
         post[:b21] = NETWORK_TOKENIZATION_CARD_SOURCE[payment_method.source.to_s]
         post[:token_eci] = post[:b21] == 'vts_mdes_token' ? '07' : nil
@@ -321,12 +344,12 @@ module ActiveMerchant #:nodoc:
       def add_customer_data(post, options)
         post[:d1] = options[:ip] || '127.0.0.1'
         if (billing_address = options[:billing_address])
-          post[:c5]   = billing_address[:address1]  if billing_address[:address1]
-          post[:c7]   = billing_address[:city]      if billing_address[:city]
-          post[:c10]  = billing_address[:zip]       if billing_address[:zip]
-          post[:c8]   = billing_address[:state]     if billing_address[:state]
-          post[:c9]   = billing_address[:country]   if billing_address[:country]
-          post[:c2]   = billing_address[:phone]     if billing_address[:phone]
+          post[:c5]   = billing_address[:address1]      if billing_address[:address1]
+          post[:c7]   = billing_address[:city]          if billing_address[:city]
+          post[:c10]  = billing_address[:zip]           if billing_address[:zip]
+          post[:c8]   = billing_address[:state]         if billing_address[:state]
+          post[:c9]   = billing_address[:country]       if billing_address[:country]
+          post[:c2]   = billing_address[:phone] if billing_address[:phone]
         end
       end
 
@@ -342,14 +365,35 @@ module ActiveMerchant #:nodoc:
         post[:c3] = options[:email] || 'unspecified@example.com'
       end
 
+      def add_sender(post, options)
+        return unless options[:sender_ref_number] || options[:sender_fund_source] || options[:sender_country_code] || options[:sender_street_address] || options[:sender_city] || options[:sender_state] || options[:sender_first_name] || options[:sender_last_name] || options[:sender_birth_date]
+
+        sender_country_code = options[:sender_country_code]&.length == 3 ? options[:sender_country_code] : Country.find(options[:sender_country_code]).code(:alpha3).value if options[:sender_country_code]
+        post[:s15] = sender_country_code
+        post[:s17] = options[:sender_ref_number] if options[:sender_ref_number]
+        post[:s18] = options[:sender_fund_source] if options[:sender_fund_source]
+        post[:s10] = options[:sender_first_name] if options[:sender_first_name]
+        post[:s11] = options[:sender_last_name] if options[:sender_last_name]
+        post[:s12] = options[:sender_street_address] if options[:sender_street_address]
+        post[:s13] = options[:sender_city] if options[:sender_city]
+        post[:s14] = options[:sender_state] if options[:sender_state]
+        post[:s19] = options[:sender_birth_date] if options[:sender_birth_date]
+      end
+
       def add_recipient(post, options)
-        return unless options[:recipient_street_address] || options[:recipient_city] || options[:recipient_province_code] || options[:recipient_country_code]
+        return unless options[:recipient_street_address] || options[:recipient_city] || options[:recipient_province_code] || options[:recipient_country_code] || options[:recipient_first_name] || options[:recipient_last_name] || options[:recipient_postal_code]
 
         recipient_country_code = options[:recipient_country_code]&.length == 3 ? options[:recipient_country_code] : Country.find(options[:recipient_country_code]).code(:alpha3).value if options[:recipient_country_code]
         post[:j6] = options[:recipient_street_address] if options[:recipient_street_address]
         post[:j7] = options[:recipient_city] if options[:recipient_city]
         post[:j8] = options[:recipient_province_code] if options[:recipient_province_code]
+        post[:j12] = options[:recipient_postal_code] if options[:recipient_postal_code]
         post[:j9] = recipient_country_code
+
+        if options[:aft]
+          post[:j5] = options[:recipient_first_name] if options[:recipient_first_name]
+          post[:j13] = options[:recipient_last_name] if options[:recipient_last_name]
+        end
       end
 
       def add_customer_name(post, options)
@@ -357,6 +401,14 @@ module ActiveMerchant #:nodoc:
         post[:j13] = options[:last_name] if options[:last_name]
       end
 
+      def add_account_name_inquiry(post, options)
+        return unless options[:account_name_inquiry].to_s == 'true'
+
+        post[:c22] = options[:first_name] if options[:first_name]
+        post[:c23] = options[:last_name] if options[:last_name]
+        post[:a9] = '5'
+      end
+
       def add_3d_secure(post, options)
         if (options[:eci] && options[:xid]) || (options[:three_d_secure] && options[:three_d_secure][:version]&.start_with?('1'))
           add_3d_secure_1_data(post, options)
@@ -417,7 +469,7 @@ module ActiveMerchant #:nodoc:
           three_d_secure_options[:eci],
           three_d_secure_options[:cavv]
         )
-        post[:'3ds_version'] = three_d_secure_options[:version]&.start_with?('2') ? '2.0' : three_d_secure_options[:version]
+        post[:'3ds_version'] = three_d_secure_options[:version] == '2' ? '2.0' : three_d_secure_options[:version]
         post[:'3ds_dstrxid'] = three_d_secure_options[:ds_transaction_id]
       end
 
@@ -436,7 +488,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_transaction_type(post, options)
-        post[:a9] = options[:transaction_type] if options[:transaction_type]
+        a9 = options[:zero_dollar_auth] ? '5' : options[:transaction_type]
+
+        post[:a9] = a9 if a9
         post[:a2] = '3' if options.dig(:metadata, :manual_entry)
       end
 
@@ -450,6 +504,10 @@ module ActiveMerchant #:nodoc:
         post[:a11] = options[:multiple_capture_count] if options[:multiple_capture_count]
       end
 
+      def add_crypto_currency_type(post, options)
+        post[:crypto_currency_type] = options[:crypto_currency_type] if options[:crypto_currency_type]
+      end
+
       ACTIONS = {
         purchase: '1',
         authorize: '2',
@@ -488,11 +546,16 @@ module ActiveMerchant #:nodoc:
         Digest::MD5.hexdigest(values.join + @options[:cipher_key])
       end
 
+      def sign_request_with_sha256(params)
+        sorted_params = sort_parameters(params)
+        Digest::SHA256.hexdigest(sorted_params.values.join + @options[:cipher_key])
+      end
+
       def post_data(action, params, reference_action)
         params.keys.each { |key| params[key] = params[key].to_s }
         params[:M] = @options[:merchant_id]
         params[:O] = request_action(action, reference_action)
-        params[:K] = sign_request(params)
+        params[:K] = @options[:use_sha256_signing] ? sign_request_with_sha256(params) : sign_request(params)
         params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
       end
 
@@ -507,7 +570,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse(body)
-        Hash[CGI::parse(body).map { |k, v| [k.upcase, v.first] }]
+        CGI::parse(body).map { |k, v| [k.upcase, v.first] }.to_h
       end
 
       def success_from(response)
@@ -521,6 +584,32 @@ module ActiveMerchant #:nodoc:
           RESPONSE_MESSAGES[response['Z6']] || response['Z3'] || 'Unable to read error message'
         end
       end
+
+      def sort_parameters(parameters)
+        # Character type lookup hash for faster classification
+        char_type_lookup = {}.tap do |lookup|
+          ('0'..'9').each { |c| lookup[c] = 0 }  # Digits
+          ('A'..'Z').each { |c| lookup[c] = 1 }  # Uppercase letters
+          # All other chars default to 2
+        end
+
+        # Memoize sort keys to avoid recalculating for the same string
+        sort_key_cache = {}
+        generate_sort_key = lambda do |str|
+          str = str.to_s
+          sort_key_cache[str] ||= str.chars.map { |char| [char_type_lookup[char] || 2, char] }
+        end
+
+        sanitize_regex = /[<>"'()\\]/
+
+        # Sort keys and build output in one pass
+        parameters.keys.
+          sort_by(&generate_sort_key).
+          each_with_object({}) do |key, sorted_params|
+          value = parameters[key]
+          sorted_params[key] = value.is_a?(String) ? value.gsub(sanitize_regex, ' ').strip : value
+        end
+      end
     end
   end
 end

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class CtPaymentGateway < Gateway
       self.test_url = 'https://test.ctpaiement.ca/v1/'
       self.live_url = 'https://www.ctpaiement.com/v1/'
@@ -155,7 +155,7 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_terminal_number(post, options)
-        post[:MerchantTerminalNumber] = options[:merchant_terminal_number] || ' ' * 5
+        post[:MerchantTerminalNumber] = options[:merchant_terminal_number] || (' ' * 5)
       end
 
       def add_money(post, money)
@@ -163,11 +163,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_operator_id(post, options)
-        post[:OperatorID] = options[:operator_id] || '0' * 8
+        post[:OperatorID] = options[:operator_id] || ('0' * 8)
       end
 
       def add_customer_data(post, options)
-        post[:CustomerNumber] = options[:customer_number] || '0' * 8
+        post[:CustomerNumber] = options[:customer_number] || ('0' * 8)
       end
 
       def add_address(post, creditcard, options)
@@ -248,7 +248,7 @@ module ActiveMerchant #:nodoc:
 
       def authorization_from(response)
         "#{response['transactionNumber']};#{response['authorizationNumber']};"\
-        "#{response['invoiceNumber']};#{response['token']};#{response['id']}"
+          "#{response['invoiceNumber']};#{response['token']};#{response['id']}"
       end
 
       def post_data(action, parameters = {})

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

@@ -1,7 +1,7 @@
 require 'digest/md5'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # Important note:
     # ===
     # Culqi merchant accounts are configured for either purchase or auth/capture

data/lib/active_merchant/billing/gateways/cyber_source/cyber_source_common.rb

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     module CyberSourceCommon
       def check_billing_field_value(default, submitted)
         if submitted.nil?