activemerchant 1.114.0 → 1.116.0

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

@@ -99,7 +99,7 @@ module ActiveMerchant #:nodoc:
         commit('refunds', "debits/#{reference_identifier_from(identifier)}/refunds", post)
       end
 
-      def store(credit_card, options={})
+      def store(credit_card, options = {})
         post = {}
 
         post[:number] = credit_card.number
@@ -156,7 +156,7 @@ module ActiveMerchant #:nodoc:
         post[:meta] = options[:meta]
       end
 
-      def commit(entity_name, path, post, method=:post)
+      def commit(entity_name, path, post, method = :post)
         raw_response =
           begin
             parse(
@@ -165,7 +165,8 @@ module ActiveMerchant #:nodoc:
                 live_url + "/#{path}",
                 post_data(post),
                 headers
-              ))
+              )
+            )
           rescue ResponseError => e
             raise unless e.response.code.to_s =~ /4\d\d/
 

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

@@ -21,12 +21,12 @@ module ActiveMerchant #:nodoc:
         '54' => STANDARD_ERROR_CODE[:expired_card]
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :username, :password)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         commit('SubmitSinglePayment') do |xml|
           xml.Transaction do
             xml.CustRef options[:order_id]
@@ -39,7 +39,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         commit('SubmitSinglePayment') do |xml|
           xml.Transaction do
             xml.CustRef options[:order_id]
@@ -52,7 +52,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         commit('SubmitSingleCapture') do |xml|
           xml.Capture do
             xml.Receipt authorization
@@ -62,7 +62,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         commit('SubmitSingleRefund') do |xml|
           xml.Refund do
             xml.Receipt authorization
@@ -72,7 +72,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         commit('SubmitSingleVoid') do |xml|
           xml.Void do
             xml.Receipt authorization
@@ -82,7 +82,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def store(payment, options={})
+      def store(payment, options = {})
         commit('TokeniseCreditCard') do |xml|
           xml.TokeniseCreditCard do
             xml.CardNumber payment.number

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

@@ -27,12 +27,12 @@ module ActiveMerchant #:nodoc:
         'void'      => 'CC.RV'
       }
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :sender, :channel, :userid, :userpwd)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment(post, payment)
@@ -42,7 +42,7 @@ module ActiveMerchant #:nodoc:
         commit('sale', post)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
         add_invoice(post, money, options)
         add_payment(post, payment)
@@ -52,7 +52,7 @@ module ActiveMerchant #:nodoc:
         commit('authonly', post)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
         post[:authorization] = authorization
         add_invoice(post, money, options)
@@ -60,7 +60,7 @@ module ActiveMerchant #:nodoc:
         commit('capture', post)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         post[:authorization] = authorization
         add_invoice(post, money, options)
@@ -68,14 +68,14 @@ module ActiveMerchant #:nodoc:
         commit('refund', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         post[:authorization] = authorization
 
         commit('void', 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) }

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

@@ -74,7 +74,7 @@ module ActiveMerchant #:nodoc:
 
       def card_brand(card)
         brand = super
-        ({'master' => 'mastercard', 'american_express' => 'amex'}[brand] || brand)
+        ({ 'master' => 'mastercard', 'american_express' => 'amex' }[brand] || brand)
       end
 
       def parse(body)

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

@@ -71,21 +71,23 @@ module ActiveMerchant #:nodoc:
         post[:shopperName] = options[:shopper_name] if options[:shopper_name]
 
         if options[:third_party_payout]
-          post[:recurring] = options[:recurring_contract] || {contract: 'PAYOUT'}
+          post[:recurring] = options[:recurring_contract] || { contract: 'PAYOUT' }
           MultiResponse.run do |r|
             r.process {
               commit(
                 'storeDetailAndSubmitThirdParty',
                 post,
                 @options[:store_payout_account],
-                @options[:store_payout_password])
+                @options[:store_payout_password]
+              )
             }
             r.process {
               commit(
                 'confirmThirdParty',
                 modification_request(r.authorization, @options),
                 @options[:review_payout_account],
-                @options[:review_payout_password])
+                @options[:review_payout_password]
+              )
             }
           end
         else
@@ -108,7 +110,7 @@ module ActiveMerchant #:nodoc:
       def store(creditcard, options = {})
         post = store_request(options)
         post[:card] = credit_card_hash(creditcard)
-        post[:recurring] = {contract: 'RECURRING'}
+        post[:recurring] = { contract: 'RECURRING' }
 
         commit('store', post)
       end

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

@@ -104,7 +104,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def verify(source, options={})
+      def verify(source, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, source, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
@@ -175,10 +175,10 @@ module ActiveMerchant #:nodoc:
       # can't actually delete a secure profile with the supplicated API. This function sets the status of the profile to closed (C).
       # Closed profiles will have to removed manually.
       def delete(vault_id)
-        update(vault_id, false, {status: 'C'})
+        update(vault_id, false, { status: 'C' })
       end
 
-      alias_method :unstore, :delete
+      alias unstore delete
 
       # Update the values (such as CC expiration) stored at
       # the gateway.  The CC number must be supplied in the

data/lib/active_merchant/billing/gateways/beanstream/beanstream_core.rb

@@ -410,15 +410,14 @@ module ActiveMerchant #:nodoc:
         recurring_post(post_data(params, false))
       end
 
-      def post(data, use_profile_api=nil)
+      def post(data, use_profile_api = nil)
         response = parse(ssl_post((use_profile_api ? SECURE_PROFILE_URL : self.live_url), data))
         response[:customer_vault_id] = response[:customerCode] if response[:customerCode]
         build_response(success?(response), message_from(response), response,
           test: test? || response[:authCode] == 'TEST',
           authorization: authorization_from(response),
           cvv_result: CVD_CODES[response[:cvdId]],
-          avs_result: { code: AVS_CODES.include?(response[:avsId]) ? AVS_CODES[response[:avsId]] : response[:avsId] }
-        )
+          avs_result: { code: AVS_CODES.include?(response[:avsId]) ? AVS_CODES[response[:avsId]] : response[:avsId] })
       end
 
       def recurring_post(data)
@@ -443,7 +442,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_source(post, source)
-        if source.is_a?(String) or source.is_a?(Integer)
+        if source.is_a?(String) || source.is_a?(Integer)
           post[:customerCode] = source
         else
           card_brand(source) == 'check' ? add_check(post, source) : add_credit_card(post, source)
@@ -468,7 +467,7 @@ module ActiveMerchant #:nodoc:
         params[:vbvEnabled] = '0'
         params[:scEnabled] = '0'
 
-        params.reject { |k, v| v.blank? }.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        params.reject { |_k, v| v.blank? }.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
     end
   end

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

@@ -332,7 +332,7 @@ module ActiveMerchant #:nodoc:
         parse(ssl_post(url, post_data(action, fields)))
       end
 
-      def parse_recurring(response_fields, opts={}) # expected status?
+      def parse_recurring(response_fields, opts = {}) # expected status?
         parsed = {}
         response_fields.each do |k, v|
           mapped_key = REBILL_FIELD_MAP.include?(k) ? REBILL_FIELD_MAP[k] : k
@@ -366,8 +366,7 @@ module ActiveMerchant #:nodoc:
           test: test?,
           authorization: (parsed[:rebid] && parsed[:rebid] != '' ? parsed[:rebid] : parsed[:transaction_id]),
           avs_result: { code: parsed[:avs_result_code] },
-          cvv_result: parsed[:card_code]
-        )
+          cvv_result: parsed[:card_code])
       end
 
       def message_from(parsed)

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

@@ -70,12 +70,12 @@ module ActiveMerchant
 
       STATE_CODE_COUNTRIES = %w(US CA)
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :api_username, :api_password)
         super
       end
 
-      def purchase(money, payment_method, options={})
+      def purchase(money, payment_method, options = {})
         payment_method_details = PaymentMethodDetails.new(payment_method)
 
         commit(:purchase, :post, payment_method_details) do |doc|
@@ -87,13 +87,13 @@ module ActiveMerchant
         end
       end
 
-      def authorize(money, payment_method, options={})
+      def authorize(money, payment_method, options = {})
         commit(:authorize) do |doc|
           add_auth_purchase(doc, money, payment_method, options)
         end
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         commit(:capture, :put) do |doc|
           add_authorization(doc, authorization)
           add_order(doc, options)
@@ -101,7 +101,7 @@ module ActiveMerchant
         end
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         commit(:refund, :put) do |doc|
           add_authorization(doc, authorization)
           add_amount(doc, money, options)
@@ -109,14 +109,14 @@ module ActiveMerchant
         end
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         commit(:void, :put) do |doc|
           add_authorization(doc, authorization)
           add_order(doc, options)
         end
       end
 
-      def verify(payment_method, options={})
+      def verify(payment_method, options = {})
         authorize(0, payment_method, options)
       end
 
@@ -329,16 +329,18 @@ module ActiveMerchant
       end
 
       def add_shipping_contact_info(doc, payment_method, options)
-        # https://developers.bluesnap.com/v8976-XML/docs/shipping-contact-info
-        doc.send('first-name', payment_method.first_name)
-        doc.send('last-name', payment_method.last_name)
-
-        doc.country(options[:shipping_country]) if options[:shipping_country]
-        doc.state(options[:shipping_state]) if options[:shipping_state] && STATE_CODE_COUNTRIES.include?(options[:shipping_country])
-        doc.address1(options[:shipping_address1]) if options[:shipping_address1]
-        doc.address2(options[:shipping_address2]) if options[:shipping_address2]
-        doc.city(options[:shipping_city]) if options[:shipping_city]
-        doc.zip(options[:shipping_zip]) if options[:shipping_zip]
+        if address = options[:shipping_address]
+          # https://developers.bluesnap.com/v8976-XML/docs/shipping-contact-info
+          doc.send('first-name', payment_method.first_name)
+          doc.send('last-name', payment_method.last_name)
+
+          doc.country(address[:country]) if address[:country]
+          doc.state(address[:state]) if address[:state] && STATE_CODE_COUNTRIES.include?(address[:country])
+          doc.address1(address[:address1]) if address[:address1]
+          doc.address2(address[:address2]) if address[:address2]
+          doc.city(address[:city]) if address[:city]
+          doc.zip(address[:zip]) if address[:zip]
+        end
       end
 
       def add_alt_transaction_purchase(doc, money, payment_method_details, options)

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

@@ -47,9 +47,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case normalize(paysource)
         when /1$/
-          Response.new(true, SUCCESS_MESSAGE, {paid_amount: money}, test: true)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end
@@ -61,9 +61,9 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, REFUND_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
-          Response.new(true, SUCCESS_MESSAGE, {paid_amount: money}, test: true)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true)
         end
       end
 
@@ -73,9 +73,9 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, CAPTURE_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
-          Response.new(true, SUCCESS_MESSAGE, {paid_amount: money}, test: true)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true)
         end
       end
 
@@ -84,18 +84,18 @@ module ActiveMerchant #:nodoc:
         when /1$/
           raise Error, VOID_ERROR_MESSAGE
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {authorization: reference, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { authorization: reference, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
-          Response.new(true, SUCCESS_MESSAGE, {authorization: reference}, test: true)
+          Response.new(true, SUCCESS_MESSAGE, { authorization: reference }, test: true)
         end
       end
 
       def store(paysource, options = {})
         case normalize(paysource)
         when /1$/
-          Response.new(true, SUCCESS_MESSAGE, {billingid: '1'}, test: true, authorization: AUTHORIZATION)
+          Response.new(true, SUCCESS_MESSAGE, { billingid: '1' }, test: true, authorization: AUTHORIZATION)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {billingid: nil, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { billingid: nil, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end
@@ -106,7 +106,7 @@ module ActiveMerchant #:nodoc:
         when /1$/
           Response.new(true, SUCCESS_MESSAGE, {}, test: true)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, UNSTORE_ERROR_MESSAGE
         end
@@ -118,9 +118,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case money
         when /00$/
-          Response.new(true, SUCCESS_MESSAGE, {authorized_amount: money}, test: true, authorization: AUTHORIZATION, emv_authorization: AUTHORIZATION_EMV_SUCCESS)
+          Response.new(true, SUCCESS_MESSAGE, { authorized_amount: money }, test: true, authorization: AUTHORIZATION, emv_authorization: AUTHORIZATION_EMV_SUCCESS)
         when /05$/
-          Response.new(false, FAILURE_MESSAGE, {authorized_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error], emv_authorization: AUTHORIZATION_EMV_DECLINE)
+          Response.new(false, FAILURE_MESSAGE, { authorized_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error], emv_authorization: AUTHORIZATION_EMV_DECLINE)
         else
           raise Error, error_message(paysource)
         end
@@ -130,9 +130,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case normalize(paysource)
         when /1$/, AUTHORIZATION
-          Response.new(true, SUCCESS_MESSAGE, {authorized_amount: money}, test: true, authorization: AUTHORIZATION)
+          Response.new(true, SUCCESS_MESSAGE, { authorized_amount: money }, test: true, authorization: AUTHORIZATION)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {authorized_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { authorized_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end
@@ -142,9 +142,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case money
         when /00$/
-          Response.new(true, SUCCESS_MESSAGE, {paid_amount: money}, test: true, authorization: AUTHORIZATION, emv_authorization: AUTHORIZATION_EMV_SUCCESS)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true, authorization: AUTHORIZATION, emv_authorization: AUTHORIZATION_EMV_SUCCESS)
         when /05$/
-          Response.new(false, FAILURE_MESSAGE, {paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error], emv_authorization: AUTHORIZATION_EMV_DECLINE)
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error], emv_authorization: AUTHORIZATION_EMV_DECLINE)
         else
           raise Error, error_message(paysource)
         end
@@ -154,9 +154,9 @@ module ActiveMerchant #:nodoc:
         money = amount(money)
         case normalize(paysource)
         when /1$/, AUTHORIZATION
-          Response.new(true, SUCCESS_MESSAGE, {paid_amount: money}, test: true, authorization: AUTHORIZATION)
+          Response.new(true, SUCCESS_MESSAGE, { paid_amount: money }, test: true, authorization: AUTHORIZATION)
         when /2$/
-          Response.new(false, FAILURE_MESSAGE, {paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+          Response.new(false, FAILURE_MESSAGE, { paid_amount: money, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
         else
           raise Error, error_message(paysource)
         end