activemerchant 1.100.0 → 1.133.0

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

@@ -1,27 +1,27 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class WorldpayOnlinePaymentsGateway < Gateway
-      self.live_url =  'https://api.worldpay.com/v1/'
+      self.live_url = 'https://api.worldpay.com/v1/'
 
       self.default_currency = 'GBP'
 
       self.money_format = :cents
 
       self.supported_countries = %w(HK US GB BE CH CZ DE DK ES FI FR GR HU IE IT LU MT NL NO PL PT SE SG TR)
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro]
+      self.supported_cardtypes = %i[visa master american_express discover jcb maestro]
 
       self.homepage_url = 'http://online.worldpay.com'
       self.display_name = 'Worldpay Online Payments'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :client_key, :service_key)
         @client_key = options[:client_key]
         @service_key = options[:service_key]
         super
       end
 
-      def authorize(money, credit_card, options={})
-        response = create_token(true, credit_card.first_name+' '+credit_card.last_name, credit_card.month, credit_card.year, credit_card.number, credit_card.verification_value)
+      def authorize(money, credit_card, options = {})
+        response = create_token(true, credit_card.first_name + ' ' + credit_card.last_name, credit_card.month, credit_card.year, credit_card.number, credit_card.verification_value)
         if response.success?
           options[:authorizeOnly] = true
           post = create_post_for_auth_or_purchase(response.authorization, money, options)
@@ -30,24 +30,23 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         if authorization
-          commit(:post, "orders/#{CGI.escape(authorization)}/capture", {'captureAmount'=>money}, options, 'capture')
+          commit(:post, "orders/#{CGI.escape(authorization)}/capture", { 'captureAmount' => money }, options, 'capture')
         else
           Response.new(false,
             'FAILED',
             'FAILED',
-            :test => test?,
-            :authorization => false,
-            :avs_result => {},
-            :cvv_result => {},
-            :error_code => false
-          )
+            test: test?,
+            authorization: false,
+            avs_result: {},
+            cvv_result: {},
+            error_code: false)
         end
       end
 
-      def purchase(money, credit_card, options={})
-        response = create_token(true, credit_card.first_name+' '+credit_card.last_name, credit_card.month, credit_card.year, credit_card.number, credit_card.verification_value)
+      def purchase(money, credit_card, options = {})
+        response = create_token(true, credit_card.first_name + ' ' + credit_card.last_name, credit_card.month, credit_card.year, credit_card.number, credit_card.verification_value)
         if response.success?
           post = create_post_for_auth_or_purchase(response.authorization, money, options)
           response = commit(:post, 'orders', post, options, 'purchase')
@@ -55,20 +54,18 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      def refund(money, orderCode, options={})
-        obj = money ? {'refundAmount' => money} : {}
+      def refund(money, orderCode, options = {})
+        obj = money ? { 'refundAmount' => money } : {}
         commit(:post, "orders/#{CGI.escape(orderCode)}/refund", obj, options, 'refund')
       end
 
-      def void(orderCode, options={})
+      def void(orderCode, options = {})
         response = commit(:delete, "orders/#{CGI.escape(orderCode)}", nil, options, 'void')
-        if !response.success? && (response.params && response.params['customCode'] != 'ORDER_NOT_FOUND')
-          response = refund(nil, orderCode)
-        end
+        response = refund(nil, orderCode) if !response.success? && (response.params && response.params['customCode'] != 'ORDER_NOT_FOUND')
         response
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         authorize(0, credit_card, options)
       end
 
@@ -76,18 +73,18 @@ module ActiveMerchant #:nodoc:
 
       def create_token(reusable, name, exp_month, exp_year, number, cvc)
         obj = {
-          'reusable'=> reusable,
-          'paymentMethod'=> {
-            'type'=> 'Card',
-            'name'=> name,
-            'expiryMonth'=> exp_month,
-            'expiryYear'=> exp_year,
-            'cardNumber'=> number,
-            'cvc'=> cvc
+          'reusable' => reusable,
+          'paymentMethod' => {
+            'type' => 'Card',
+            'name' => name,
+            'expiryMonth' => exp_month,
+            'expiryYear' => exp_year,
+            'cardNumber' => number,
+            'cvc' => cvc
           },
-          'clientKey'=> @client_key
+          'clientKey' => @client_key
         }
-        token_response = commit(:post, 'tokens', obj, {'Authorization' => @service_key}, 'token')
+        token_response = commit(:post, 'tokens', obj, { 'Authorization' => @service_key }, 'token')
         token_response
       end
 
@@ -97,16 +94,16 @@ module ActiveMerchant #:nodoc:
           'orderDescription' => options[:description] || 'Worldpay Order',
           'amount' => money,
           'currencyCode' => options[:currency] || default_currency,
-          'name' => options[:billing_address]&&options[:billing_address][:name] ? options[:billing_address][:name] : '',
+          'name' => options[:billing_address] && options[:billing_address][:name] ? options[:billing_address][:name] : '',
           'billingAddress' => {
-            'address1'=>options[:billing_address]&&options[:billing_address][:address1] ? options[:billing_address][:address1] : '',
-            'address2'=>options[:billing_address]&&options[:billing_address][:address2] ? options[:billing_address][:address2] : '',
-            'address3'=>'',
-            'postalCode'=>options[:billing_address]&&options[:billing_address][:zip] ? options[:billing_address][:zip] : '',
-            'city'=>options[:billing_address]&&options[:billing_address][:city] ? options[:billing_address][:city] : '',
-            'state'=>options[:billing_address]&&options[:billing_address][:state] ? options[:billing_address][:state] : '',
-            'countryCode'=>options[:billing_address]&&options[:billing_address][:country] ? options[:billing_address][:country] : ''
-           },
+            'address1' => options[:billing_address] && options[:billing_address][:address1] ? options[:billing_address][:address1] : '',
+            'address2' => options[:billing_address] && options[:billing_address][:address2] ? options[:billing_address][:address2] : '',
+            'address3' => '',
+            'postalCode' => options[:billing_address] && options[:billing_address][:zip] ? options[:billing_address][:zip] : '',
+            'city' => options[:billing_address] && options[:billing_address][:city] ? options[:billing_address][:city] : '',
+            'state' => options[:billing_address] && options[:billing_address][:state] ? options[:billing_address][:state] : '',
+            'countryCode' => options[:billing_address] && options[:billing_address][:country] ? options[:billing_address][:country] : ''
+          },
           'customerOrderCode' => options[:order_id],
           'orderType' => 'ECOM',
           'authorizeOnly' => options[:authorizeOnly] ? true : false
@@ -123,15 +120,13 @@ module ActiveMerchant #:nodoc:
           'Content-Type' => 'application/json',
           'User-Agent' => "Worldpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
           'X-Worldpay-Client-User-Agent' => user_agent,
-          'X-Worldpay-Client-User-Metadata' => {:ip => options[:ip]}.to_json
+          'X-Worldpay-Client-User-Metadata' => { ip: options[:ip] }.to_json
         }
-        if options['Authorization']
-          headers['Authorization'] = options['Authorization']
-        end
+        headers['Authorization'] = options['Authorization'] if options['Authorization']
         headers
       end
 
-      def commit(method, url, parameters=nil, options = {}, type = false)
+      def commit(method, url, parameters = nil, options = {}, type = false)
         raw_response = response = nil
         success = false
         begin
@@ -151,7 +146,7 @@ module ActiveMerchant #:nodoc:
                   success = true
                 elsif type == 'purchase' && response['paymentStatus'] == 'SUCCESS'
                   success = true
-                elsif type == 'capture' || type=='refund' || type=='void'
+                elsif type == 'capture' || type == 'refund' || type == 'void'
                   success = true
                 end
               end
@@ -178,12 +173,11 @@ module ActiveMerchant #:nodoc:
         Response.new(success,
           success ? 'SUCCESS' : response['message'],
           response,
-          :test => test?,
-          :authorization => authorization,
-          :avs_result => {},
-          :cvv_result => {},
-          :error_code => success ? nil : response['customCode']
-        )
+          test: test?,
+          authorization: authorization,
+          avs_result: {},
+          cvv_result: {},
+          error_code: success ? nil : response['customCode'])
       end
 
       def test?
@@ -209,7 +203,6 @@ module ActiveMerchant #:nodoc:
       def handle_response(response)
         response.body
       end
-
     end
   end
 end

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

@@ -15,14 +15,14 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['US']
       self.default_currency = 'USD'
       self.money_format = :dollars
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb]
+      self.supported_cardtypes = %i[visa master american_express discover jcb]
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :acctid, :subid, :merchantpin)
         super
       end
 
-      def purchase(money, payment_method, options={})
+      def purchase(money, payment_method, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment_method(post, payment_method)
@@ -31,7 +31,7 @@ module ActiveMerchant #:nodoc:
         commit('purchase', options, post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_credit_card(post, payment)
@@ -40,7 +40,7 @@ module ActiveMerchant #:nodoc:
         commit('authorize', options, post)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization)
@@ -49,7 +49,7 @@ module ActiveMerchant #:nodoc:
         commit('capture', options, post)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization)
@@ -58,14 +58,14 @@ module ActiveMerchant #:nodoc:
         commit('refund', options, post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_reference(post, authorization)
 
         commit('void', options, post)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -91,7 +91,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_customer_data(post, options)
-        if(billing_address = (options[:billing_address] || options[:address]))
+        if (billing_address = (options[:billing_address] || options[:address]))
           post[:ci_companyname] = billing_address[:company]
           post[:ci_billaddr1]   = billing_address[:address1]
           post[:ci_billaddr2]   = billing_address[:address2]
@@ -105,13 +105,13 @@ module ActiveMerchant #:nodoc:
           post[:ci_ipaddress]   = billing_address[:ip]
         end
 
-        if(shipping_address = options[:shipping_address])
+        if (shipping_address = options[:shipping_address])
           post[:ci_shipaddr1] = shipping_address[:address1]
           post[:ci_shipaddr2] = shipping_address[:address2]
           post[:ci_shipcity] = shipping_address[:city]
           post[:ci_shipstate] = shipping_address[:state]
-          post[:ci_shipzip]    = shipping_address[:zip]
-          post[:ci_shipcountry]    = shipping_address[:country]
+          post[:ci_shipzip] = shipping_address[:zip]
+          post[:ci_shipcountry] = shipping_address[:country]
         end
       end
 
@@ -139,7 +139,7 @@ module ActiveMerchant #:nodoc:
 
       ACCOUNT_TYPES = {
         'checking' => '1',
-        'savings' => '2',
+        'savings' => '2'
       }
 
       def add_check(post, payment_method)
@@ -178,7 +178,7 @@ module ActiveMerchant #:nodoc:
         'refund' => 'ns_credit',
         'authorize' => 'ns_quicksale_cc',
         'capture' => 'ns_quicksale_cc',
-        'void' => 'ns_void',
+        'void' => 'ns_void'
       }
 
       def commit(action, options, post)
@@ -196,8 +196,8 @@ module ActiveMerchant #:nodoc:
           succeeded,
           message_from(succeeded, raw),
           raw,
-          :authorization => authorization_from(raw),
-          :test => test?
+          authorization: authorization_from(raw),
+          test: test?
         )
       end
 

data/lib/active_merchant/billing/network_tokenization_credit_card.rb

@@ -14,10 +14,10 @@ module ActiveMerchant #:nodoc:
       self.require_verification_value = false
       self.require_name = false
 
-      attr_accessor :payment_cryptogram, :eci, :transaction_id
+      attr_accessor :payment_cryptogram, :eci, :transaction_id, :metadata
       attr_writer :source
 
-      SOURCES = %i(apple_pay android_pay google_pay)
+      SOURCES = %i(apple_pay android_pay google_pay network_token)
 
       def source
         if defined?(@source) && SOURCES.include?(@source)

data/lib/active_merchant/billing/response.rb

@@ -4,12 +4,16 @@ module ActiveMerchant #:nodoc:
     end
 
     class Response
-      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result, :error_code, :emv_authorization
+      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result, :error_code, :emv_authorization, :network_transaction_id
 
       def success?
         @success
       end
 
+      def failure?
+        !success?
+      end
+
       def test?
         @test
       end
@@ -25,18 +29,19 @@ module ActiveMerchant #:nodoc:
         @fraud_review = options[:fraud_review]
         @error_code = options[:error_code]
         @emv_authorization = options[:emv_authorization]
+        @network_transaction_id = options[:network_transaction_id]
 
         @avs_result = if options[:avs_result].kind_of?(AVSResult)
                         options[:avs_result].to_hash
                       else
                         AVSResult.new(options[:avs_result]).to_hash
-        end
+                      end
 
         @cvv_result = if options[:cvv_result].kind_of?(CVVResult)
                         options[:cvv_result].to_hash
                       else
                         CVVResult.new(options[:cvv_result]).to_hash
-        end
+                      end
       end
     end
 
@@ -53,14 +58,14 @@ module ActiveMerchant #:nodoc:
         @primary_response = nil
       end
 
-      def process(ignore_result=false)
+      def process(ignore_result = false)
         return unless success?
 
         response = yield
         self << response
 
         unless ignore_result
-          if(@use_first_response && response.success?)
+          if @use_first_response && response.success?
             @primary_response ||= response
           else
             @primary_response = response
@@ -80,7 +85,21 @@ module ActiveMerchant #:nodoc:
         (primary_response ? primary_response.success? : true)
       end
 
-      %w(params message test authorization avs_result cvv_result error_code emv_authorization test? fraud_review?).each do |m|
+      def avs_result
+        return @primary_response.try(:avs_result) if @use_first_response
+
+        result = responses.reverse.find { |r| r.avs_result['code'].present? }
+        result.try(:avs_result) || responses.last.try(:avs_result)
+      end
+
+      def cvv_result
+        return @primary_response.try(:cvv_result) if @use_first_response
+
+        result = responses.reverse.find { |r| r.cvv_result['code'].present? }
+        result.try(:cvv_result) || responses.last.try(:cvv_result)
+      end
+
+      %w(params message test authorization error_code emv_authorization test? fraud_review?).each do |m|
         class_eval %(
           def #{m}
             (@responses.empty? ? nil : primary_response.#{m})

data/lib/active_merchant/billing/three_d_secure_eci_mapper.rb

@@ -0,0 +1,27 @@
+module ActiveMerchant
+  module Billing
+    module ThreeDSecureEciMapper
+      NON_THREE_D_SECURE_TRANSACTION = :non_three_d_secure_transaction
+      ATTEMPTED_AUTHENTICATION_TRANSACTION = :attempted_authentication_transaction
+      FULLY_AUTHENTICATED_TRANSACTION = :fully_authenticated_transaction
+
+      ECI_00_01_02_MAP = { '00' => NON_THREE_D_SECURE_TRANSACTION, '01' => ATTEMPTED_AUTHENTICATION_TRANSACTION, '02' => FULLY_AUTHENTICATED_TRANSACTION }.freeze
+      ECI_05_06_07_MAP = { '05' => FULLY_AUTHENTICATED_TRANSACTION, '06' => ATTEMPTED_AUTHENTICATION_TRANSACTION, '07' => NON_THREE_D_SECURE_TRANSACTION }.freeze
+      BRAND_TO_ECI_MAP = {
+        american_express: ECI_05_06_07_MAP,
+        dankort: ECI_05_06_07_MAP,
+        diners_club: ECI_05_06_07_MAP,
+        discover: ECI_05_06_07_MAP,
+        elo: ECI_05_06_07_MAP,
+        jcb: ECI_05_06_07_MAP,
+        maestro: ECI_00_01_02_MAP,
+        master: ECI_00_01_02_MAP,
+        visa: ECI_05_06_07_MAP
+      }.freeze
+
+      def self.map(brand, eci)
+        BRAND_TO_ECI_MAP.dig(brand, eci)
+      end
+    end
+  end
+end

data/lib/active_merchant/billing.rb

@@ -13,3 +13,4 @@ require 'active_merchant/billing/apple_pay_payment_token'
 require 'active_merchant/billing/response'
 require 'active_merchant/billing/gateways'
 require 'active_merchant/billing/gateway'
+require 'active_merchant/billing/three_d_secure_eci_mapper'

data/lib/active_merchant/connection.rb

@@ -62,6 +62,7 @@ module ActiveMerchant
 
     def wiredump_device=(device)
       raise ArgumentError, "can't wiredump to frozen #{device.class}" if device&.frozen?
+
       @wiredump_device = device
     end
 
@@ -71,20 +72,19 @@ module ActiveMerchant
       headers = headers.dup
       headers['connection'] ||= 'close'
 
-      retry_exceptions(:max_retries => max_retries, :logger => logger, :tag => tag) do
-        begin
-          info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
+      retry_exceptions(max_retries: max_retries, logger: logger, tag: tag) do
+        info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
 
-          result = nil
+        result = nil
 
-          realtime = Benchmark.realtime do
-            http.start unless http.started?
-            @ssl_connection = http.ssl_connection
-            info "connection_ssl_version=#{ssl_connection[:version]} connection_ssl_cipher=#{ssl_connection[:cipher]}", tag
+        realtime = Benchmark.realtime do
+          http.start unless http.started?
+          @ssl_connection = http.ssl_connection
+          info "connection_ssl_version=#{ssl_connection[:version]} connection_ssl_cipher=#{ssl_connection[:cipher]}", tag
 
-            result = case method
+          result =
+            case method
             when :get
-              raise ArgumentError, 'GET requests do not support a request body' if body
               http.get(endpoint.request_uri, headers)
             when :post
               debug body
@@ -110,12 +110,11 @@ module ActiveMerchant
             else
               raise ArgumentError, "Unsupported request method #{method.to_s.upcase}"
             end
-          end
-
-          info '--> %d %s (%d %.4fs)' % [result.code, result.message, result.body ? result.body.length : 0, realtime], tag
-          debug result.body
-          result
         end
+
+        info '--> %d %s (%d %.4fs)' % [result.code, result.message, result.body ? result.body.length : 0, realtime], tag
+        debug result.body
+        result
       end
     ensure
       info 'connection_request_total_time=%.4fs' % [Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start], tag

data/lib/active_merchant/country.rb

@@ -39,7 +39,7 @@ module ActiveMerchant #:nodoc:
 
     def initialize(options = {})
       @name = options.delete(:name)
-      @codes = options.collect { |k, v| CountryCode.new(v) }
+      @codes = options.collect { |_k, v| CountryCode.new(v) }
     end
 
     def code(format)
@@ -184,6 +184,7 @@ module ActiveMerchant #:nodoc:
       { alpha2: 'KP', name: 'Korea, Democratic People\'s Republic of', alpha3: 'PRK', numeric: '408' },
       { alpha2: 'KR', name: 'Korea, Republic of', alpha3: 'KOR', numeric: '410' },
       { alpha2: 'XK', name: 'Kosovo', alpha3: 'XKX', numeric: '900' },
+      { alpha2: 'QZ', name: 'Kosovo', alpha3: 'XKX', numeric: '900' },
       { alpha2: 'KW', name: 'Kuwait', alpha3: 'KWT', numeric: '414' },
       { alpha2: 'KG', name: 'Kyrgyzstan', alpha3: 'KGZ', numeric: '417' },
       { alpha2: 'LA', name: 'Lao People\'s Democratic Republic', alpha3: 'LAO', numeric: '418' },
@@ -330,6 +331,7 @@ module ActiveMerchant #:nodoc:
         country = COUNTRIES.detect { |c| c[:name].casecmp(name).zero? }
       end
       raise InvalidCountryCodeError, "No country could be found for the country #{name}" if country.nil?
+
       Country.new(country.dup)
     end
   end

data/lib/active_merchant/errors.rb

@@ -23,10 +23,13 @@ module ActiveMerchant #:nodoc:
     end
 
     def to_s
-      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+      "Failed with #{response.code if response.respond_to?(:code)} #{response.message if response.respond_to?(:message)}"
     end
   end
 
+  class OAuthResponseError < ResponseError # :nodoc:
+  end
+
   class ClientCertificateError < ActiveMerchantError # :nodoc
   end
 

data/lib/active_merchant/net_http_ssl_connection.rb

@@ -4,6 +4,7 @@ module NetHttpSslConnection
   refine Net::HTTP do
     def ssl_connection
       return {} unless use_ssl? && @socket.present?
+
       { version: @socket.io.ssl_version, cipher: @socket.io.cipher[0] }
     end
   end

data/lib/active_merchant/network_connection_retries.rb

@@ -17,26 +17,24 @@ module ActiveMerchant
       base.send(:attr_accessor, :retry_safe)
     end
 
-    def retry_exceptions(options={})
+    def retry_exceptions(options = {})
       connection_errors = DEFAULT_CONNECTION_ERRORS.merge(options[:connection_exceptions] || {})
 
       retry_network_exceptions(options) do
-        begin
-          yield
-        rescue Errno::ECONNREFUSED => e
-          raise ActiveMerchant::RetriableConnectionError.new('The remote server refused the connection', e)
-        rescue OpenSSL::X509::CertificateError => e
-          NetworkConnectionRetries.log(options[:logger], :error, e.message, options[:tag])
-          raise ActiveMerchant::ClientCertificateError, 'The remote server did not accept the provided SSL certificate'
-        rescue Zlib::BufError
-          raise ActiveMerchant::InvalidResponseError, 'The remote server replied with an invalid response'
-        rescue *connection_errors.keys => e
-          raise ActiveMerchant::ConnectionError.new(derived_error_message(connection_errors, e.class), e)
-        end
+        yield
+      rescue Errno::ECONNREFUSED => e
+        raise ActiveMerchant::RetriableConnectionError.new('The remote server refused the connection', e)
+      rescue OpenSSL::X509::CertificateError => e
+        NetworkConnectionRetries.log(options[:logger], :error, e.message, options[:tag])
+        raise ActiveMerchant::ClientCertificateError, 'The remote server did not accept the provided SSL certificate'
+      rescue Zlib::BufError
+        raise ActiveMerchant::InvalidResponseError, 'The remote server replied with an invalid response'
+      rescue *connection_errors.keys => e
+        raise ActiveMerchant::ConnectionError.new(derived_error_message(connection_errors, e.class), e)
       end
     end
 
-    def self.log(logger, level, message, tag=nil)
+    def self.log(logger, level, message, tag = nil)
       tag ||= self.class.to_s
       message = "[#{tag}] #{message}"
       logger&.send(level, message)
@@ -52,17 +50,17 @@ module ActiveMerchant
       begin
         request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         result = yield
-        log_with_retry_details(options[:logger], initial_retries-retries + 1, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, 'success', options[:tag])
+        log_with_retry_details(options[:logger], initial_retries - retries + 1, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, 'success', options[:tag])
         result
       rescue ActiveMerchant::RetriableConnectionError => e
         retries -= 1
 
-        log_with_retry_details(options[:logger], initial_retries-retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
+        log_with_retry_details(options[:logger], initial_retries - retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
         retry unless retries.zero?
         raise ActiveMerchant::ConnectionError.new(e.message, e)
       rescue ActiveMerchant::ConnectionError, ActiveMerchant::InvalidResponseError => e
         retries -= 1
-        log_with_retry_details(options[:logger], initial_retries-retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
+        log_with_retry_details(options[:logger], initial_retries - retries, Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start, e.message, options[:tag])
         retry if (options[:retry_safe] || retry_safe) && !retries.zero?
         raise
       end

data/lib/active_merchant/post_data.rb

@@ -2,11 +2,12 @@ require 'cgi'
 
 module ActiveMerchant
   class PostData < Hash
-    class_attribute :required_fields, :instance_writer => false
+    class_attribute :required_fields, instance_writer: false
     self.required_fields = []
 
     def []=(key, value)
       return if value.blank? && !required?(key)
+
       super
     end
 
@@ -14,7 +15,7 @@ module ActiveMerchant
       collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
     end
 
-    alias_method :to_s, :to_post_data
+    alias to_s to_post_data
 
     private
 

data/lib/active_merchant/posts_data.rb

@@ -1,5 +1,5 @@
 module ActiveMerchant #:nodoc:
-  module PostsData  #:nodoc:
+  module PostsData #:nodoc:
     def self.included(base)
       base.class_attribute :ssl_strict
       base.ssl_strict = true
@@ -32,7 +32,7 @@ module ActiveMerchant #:nodoc:
       base.class_attribute :proxy_port
     end
 
-    def ssl_get(endpoint, headers={})
+    def ssl_get(endpoint, headers = {})
       ssl_request(:get, endpoint, nil, headers)
     end
 

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.100.0'
+  VERSION = '1.133.0'
 end