activemerchant 1.79.2 → 1.129.0

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

@@ -1,11 +1,11 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CecabankGateway < Gateway
-      self.test_url = 'http://tpv.ceca.es:8000'
+      self.test_url = 'https://tpv.ceca.es'
       self.live_url = 'https://pgw.ceca.es'
 
       self.supported_countries = ['ES']
-      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_cardtypes = %i[visa master american_express]
       self.homepage_url = 'http://www.ceca.es/es/'
       self.display_name = 'Cecabank'
       self.default_currency = 'EUR'
@@ -13,15 +13,15 @@ module ActiveMerchant #:nodoc:
 
       #### CECA's MAGIC NUMBERS
       CECA_NOTIFICATIONS_URL = 'NONE'
-      CECA_ENCRIPTION = 'SHA1'
+      CECA_ENCRIPTION = 'SHA2'
       CECA_DECIMALS = '2'
       CECA_MODE = 'SSL'
       CECA_UI_LESS_LANGUAGE = 'XML'
       CECA_UI_LESS_LANGUAGE_REFUND = '1'
       CECA_UI_LESS_REFUND_PAGE = 'anulacion_xml'
-      CECA_ACTION_REFUND   = 'tpvanularparcialmente' #use partial refund's URL to avoid time frame limitations and decision logic on client side
-      CECA_ACTION_PURCHASE = 'tpv'
-      CECA_CURRENCIES_DICTIONARY = {'EUR' => 978, 'USD' => 840, 'GBP' => 826}
+      CECA_ACTION_REFUND   = 'anulaciones/anularParcial' # use partial refund's URL to avoid time frame limitations and decision logic on client side
+      CECA_ACTION_PURCHASE = 'tpv/compra'
+      CECA_CURRENCIES_DICTIONARY = { 'EUR' => 978, 'USD' => 840, 'GBP' => 826 }
 
       # Creates a new CecabankGateway
       #
@@ -57,14 +57,14 @@ module ActiveMerchant #:nodoc:
       def purchase(money, creditcard, options = {})
         requires!(options, :order_id)
 
-        post = {'Descripcion' => options[:description],
+        post = { 'Descripcion' => options[:description],
                 'Num_operacion' => options[:order_id],
                 'Idioma' => CECA_UI_LESS_LANGUAGE,
                 'Pago_soportado' => CECA_MODE,
                 'URL_OK' => CECA_NOTIFICATIONS_URL,
                 'URL_NOK' => CECA_NOTIFICATIONS_URL,
                 'Importe' => amount(money),
-                'TipoMoneda' => CECA_CURRENCIES_DICTIONARY[options[:currency] || currency(money)]}
+                'TipoMoneda' => CECA_CURRENCIES_DICTIONARY[options[:currency] || currency(money)] }
 
         add_creditcard(post, creditcard)
 
@@ -84,12 +84,12 @@ module ActiveMerchant #:nodoc:
       def refund(money, identification, options = {})
         reference, order_id = split_authorization(identification)
 
-        post = {'Referencia' => reference,
+        post = { 'Referencia' => reference,
                 'Num_operacion' => order_id,
                 'Idioma' => CECA_UI_LESS_LANGUAGE_REFUND,
                 'Pagina' => CECA_UI_LESS_REFUND_PAGE,
                 'Importe' => amount(money),
-                'TipoMoneda' => CECA_CURRENCIES_DICTIONARY[options[:currency] || currency(money)]}
+                'TipoMoneda' => CECA_CURRENCIES_DICTIONARY[options[:currency] || currency(money)] }
 
         commit(CECA_ACTION_REFUND, post)
       end
@@ -123,14 +123,14 @@ module ActiveMerchant #:nodoc:
 
         root = REXML::Document.new(body).root
 
-        response[:success] = (root.attributes['valor'] == "OK")
+        response[:success] = (root.attributes['valor'] == 'OK')
         response[:date] = root.attributes['fecha']
         response[:operation_number] = root.attributes['numeroOperacion']
         response[:message] = root.attributes['valor']
 
         if root.elements['OPERACION']
           response[:operation_type] = root.elements['OPERACION'].attributes['tipo']
-          response[:amount] =  root.elements['OPERACION/importe'].text.strip
+          response[:amount] = root.elements['OPERACION/importe'].text.strip
         end
 
         response[:description] = root.elements['OPERACION/descripcion'].text if root.elements['OPERACION/descripcion']
@@ -142,20 +142,17 @@ module ActiveMerchant #:nodoc:
           response[:error_code] = root.elements['ERROR/codigo'].text
           response[:error_message] = root.elements['ERROR/descripcion'].text
         else
-          if("000" == root.elements['OPERACION'].attributes['numeroOperacion'])
-            if(root.elements['OPERACION/numeroAutorizacion'])
-              response[:authorization] = root.elements['OPERACION/numeroAutorizacion'].text
-            end
+          if root.elements['OPERACION'].attributes['numeroOperacion'] == '000'
+            response[:authorization] = root.elements['OPERACION/numeroAutorizacion'].text if root.elements['OPERACION/numeroAutorizacion']
           else
             response[:authorization] = root.attributes['numeroOperacion']
           end
         end
 
         return response
-
       rescue REXML::ParseException => e
         response[:success] = false
-        response[:message] = "Unable to parse the response."
+        response[:message] = 'Unable to parse the response.'
         response[:error_message] = e.message
         response
       end
@@ -169,23 +166,35 @@ module ActiveMerchant #:nodoc:
           'AcquirerBIN' => options[:acquirer_bin],
           'TerminalID' => options[:terminal_id]
         )
-        url = (test? ? self.test_url : self.live_url) + "/cgi-bin/#{action}"
-        xml = ssl_post(url, post_data(parameters))
+        url = (test? ? self.test_url : self.live_url) + "/tpvweb/#{action}.action"
+        xml = ssl_post("#{url}?", post_data(parameters))
         response = parse(xml)
         Response.new(
           response[:success],
-          response[:message],
+          message_from(response),
           response,
-          :test => test?,
-          :authorization => build_authorization(response)
+          test: test?,
+          authorization: build_authorization(response),
+          error_code: response[:error_code]
         )
       end
 
+      def message_from(response)
+        if response[:message] == 'ERROR' && response[:error_message]
+          response[:error_message]
+        elsif response[:error_message]
+          "#{response[:message]} #{response[:error_message]}"
+        else
+          response[:message]
+        end
+      end
+
       def post_data(params)
         return nil unless params
 
         params.map do |key, value|
           next if value.blank?
+
           if value.is_a?(Hash)
             h = {}
             value.each do |k, v|
@@ -195,44 +204,45 @@ module ActiveMerchant #:nodoc:
           else
             "#{key}=#{CGI.escape(value.to_s)}"
           end
-        end.compact.join("&")
+        end.compact.join('&')
       end
 
       def build_authorization(response)
-        [response[:reference], response[:authorization]].join("|")
+        [response[:reference], response[:authorization]].join('|')
       end
 
       def split_authorization(authorization)
-        authorization.split("|")
+        authorization.split('|')
       end
 
       def generate_signature(action, parameters)
-        signature_fields = case action
-        when CECA_ACTION_REFUND
-          options[:key].to_s +
-          options[:merchant_id].to_s +
-          options[:acquirer_bin].to_s +
-          options[:terminal_id].to_s +
-          parameters['Num_operacion'].to_s +
-          parameters['Importe'].to_s +
-          parameters['TipoMoneda'].to_s +
-          CECA_DECIMALS +
-          parameters['Referencia'].to_s +
-          CECA_ENCRIPTION
-        else
-          options[:key].to_s +
-          options[:merchant_id].to_s +
-          options[:acquirer_bin].to_s +
-          options[:terminal_id].to_s +
-          parameters['Num_operacion'].to_s +
-          parameters['Importe'].to_s +
-          parameters['TipoMoneda'].to_s +
-          CECA_DECIMALS +
-          CECA_ENCRIPTION +
-          CECA_NOTIFICATIONS_URL +
-          CECA_NOTIFICATIONS_URL
-        end
-        Digest::SHA1.hexdigest(signature_fields)
+        signature_fields =
+          case action
+          when CECA_ACTION_REFUND
+            options[:key].to_s +
+            options[:merchant_id].to_s +
+            options[:acquirer_bin].to_s +
+            options[:terminal_id].to_s +
+            parameters['Num_operacion'].to_s +
+            parameters['Importe'].to_s +
+            parameters['TipoMoneda'].to_s +
+            CECA_DECIMALS +
+            parameters['Referencia'].to_s +
+            CECA_ENCRIPTION
+          else
+            options[:key].to_s +
+            options[:merchant_id].to_s +
+            options[:acquirer_bin].to_s +
+            options[:terminal_id].to_s +
+            parameters['Num_operacion'].to_s +
+            parameters['Importe'].to_s +
+            parameters['TipoMoneda'].to_s +
+            CECA_DECIMALS +
+            CECA_ENCRIPTION +
+            CECA_NOTIFICATIONS_URL +
+            CECA_NOTIFICATIONS_URL
+          end
+        Digest::SHA2.hexdigest(signature_fields)
       end
     end
   end

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

@@ -1,51 +1,51 @@
-require "nokogiri"
+require 'nokogiri'
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CenposGateway < Gateway
-      self.display_name = "CenPOS"
-      self.homepage_url = "https://www.cenpos.com/"
+      self.display_name = 'CenPOS'
+      self.homepage_url = 'https://www.cenpos.com/'
 
-      self.live_url = "https://ww3.cenpos.net/6/transact.asmx"
+      self.live_url = 'https://ww3.cenpos.net/6/transact.asmx'
 
-      self.supported_countries = %w(AD AI AG AR AU AT BS BB BE BZ BM BR BN BG CA HR CY CZ DK DM EE FI FR DE GR GD GY HK HU IS IN IL IT JP LV LI LT LU MY MT MX MC MS NL PA PL PT KN LC MF VC SM SG SK SI ZA ES SR SE CH TR GB US UY)
-      self.default_currency = "USD"
+      self.supported_countries = %w(AD AI AG AR AU AT BS BB BE BZ BM BR BN BG CA HR CY CZ DK DM EE FI FR DE GR GD GY HK HU IS IL IT JP LV LI LT LU MY MT MX MC MS NL PA PL PT KN LC MF VC SM SG SK SI ZA ES SR SE CH TR GB US UY)
+      self.default_currency = 'USD'
       self.money_format = :dollars
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.supported_cardtypes = %i[visa master american_express discover]
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :merchant_id, :password, :user_id)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
         add_customer_data(post, options)
 
-        commit("Sale", post)
+        commit('Sale', post)
       end
 
-      def authorize(amount, payment_method, options={})
+      def authorize(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
         add_customer_data(post, options)
 
-        commit("Auth", post)
+        commit('Auth', post)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization)
         add_customer_data(post, options)
 
-        commit("SpecialForce", post)
+        commit('SpecialForce', post)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
         add_void_required_elements(post)
         add_reference(post, authorization)
@@ -53,27 +53,27 @@ module ActiveMerchant #:nodoc:
         add_tax(post, options)
         add_order_id(post, options)
 
-        commit("Void", post)
+        commit('Void', post)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization)
         add_customer_data(post, options)
 
-        commit("SpecialReturn", post)
+        commit('SpecialReturn', post)
       end
 
-      def credit(amount, payment_method, options={})
+      def credit(amount, payment_method, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
 
-        commit("Credit", post)
+        commit('Credit', 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) }
@@ -112,7 +112,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[:CustomerEmailAddress] = billing_address[:email]
           post[:CustomerPhone] = billing_address[:phone]
           post[:CustomerBillingAddress] = billing_address[:address1]
@@ -156,9 +156,9 @@ module ActiveMerchant #:nodoc:
           xml = ssl_post(self.live_url, data, headers)
           raw = parse(xml)
         rescue ActiveMerchant::ResponseError => e
-          if(e.response.code == "500" && e.response.body.start_with?("<s:Envelope"))
+          if e.response.code == '500' && e.response.body.start_with?('<s:Envelope')
             raw = {
-              message: "See transcript for detailed error description."
+              message: 'See transcript for detailed error description.'
             }
           else
             raise
@@ -180,17 +180,17 @@ module ActiveMerchant #:nodoc:
 
       def headers
         {
-          "Accept-Encoding" => "identity",
-          "Content-Type"  => "text/xml;charset=UTF-8",
-          "SOAPAction"  => "http://tempuri.org/Transactional/ProcessCreditCard"
+          'Accept-Encoding' => 'identity',
+          'Content-Type' => 'text/xml;charset=UTF-8',
+          'SOAPAction' => 'http://tempuri.org/Transactional/ProcessCreditCard'
         }
       end
 
       def build_request(post)
-        xml = Builder::XmlMarkup.new :indent => 8
-        xml.tag!("acr:MerchantId", post.delete(:MerchantId))
-        xml.tag!("acr:Password", post.delete(:Password))
-        xml.tag!("acr:UserId", post.delete(:UserId))
+        xml = Builder::XmlMarkup.new indent: 8
+        xml.tag!('acr:MerchantId', post.delete(:MerchantId))
+        xml.tag!('acr:Password', post.delete(:Password))
+        xml.tag!('acr:UserId', post.delete(:UserId))
         post.sort.each do |field, value|
           xml.tag!("acr1:#{field}", value)
         end
@@ -198,18 +198,18 @@ module ActiveMerchant #:nodoc:
       end
 
       def envelope(body)
-        <<-EOS
-<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/" xmlns:acr="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.Common" xmlns:acr1="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.v6.Common" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-<soapenv:Header/>
-   <soapenv:Body>
-      <tem:ProcessCreditCard>
-         <tem:request>
-           #{body}
-         </tem:request>
-      </tem:ProcessCreditCard>
-   </soapenv:Body>
-</soapenv:Envelope>
-        EOS
+        <<~XML
+          <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/" xmlns:acr="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.Common" xmlns:acr1="http://schemas.datacontract.org/2004/07/Acriter.ABI.CenPOS.EPayment.VirtualTerminal.v6.Common" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+          <soapenv:Header/>
+             <soapenv:Body>
+                <tem:ProcessCreditCard>
+                   <tem:request>
+                     #{body}
+                   </tem:request>
+                </tem:ProcessCreditCard>
+             </soapenv:Body>
+          </soapenv:Envelope>
+        XML
       end
 
       def parse(xml)
@@ -217,9 +217,9 @@ module ActiveMerchant #:nodoc:
 
         doc = Nokogiri::XML(xml)
         doc.remove_namespaces!
-        body = doc.xpath("//ProcessCreditCardResult")
+        body = doc.xpath('//ProcessCreditCardResult')
         body.children.each do |node|
-          if (node.elements.size == 0)
+          if node.elements.size == 0
             response[node.name.underscore.to_sym] = node.text
           else
             node.elements.each do |childnode|
@@ -233,32 +233,32 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response)
-        response == "0"
+        response == '0'
       end
 
       def message_from(succeeded, response)
         if succeeded
-          "Succeeded"
+          'Succeeded'
         else
-          response[:message] || "Unable to read error message"
+          response[:message] || 'Unable to read error message'
         end
       end
 
       STANDARD_ERROR_CODE_MAPPING = {
-        "211" => STANDARD_ERROR_CODE[:invalid_number],
-        "252" => STANDARD_ERROR_CODE[:invalid_expiry_date],
-        "257" => STANDARD_ERROR_CODE[:invalid_cvc],
-        "333" => STANDARD_ERROR_CODE[:expired_card],
-        "1" => STANDARD_ERROR_CODE[:card_declined],
-        "99" => STANDARD_ERROR_CODE[:processing_error],
+        '211' => STANDARD_ERROR_CODE[:invalid_number],
+        '252' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '257' => STANDARD_ERROR_CODE[:invalid_cvc],
+        '333' => STANDARD_ERROR_CODE[:expired_card],
+        '1' => STANDARD_ERROR_CODE[:card_declined],
+        '99' => STANDARD_ERROR_CODE[:processing_error]
       }
 
       def authorization_from(request, response)
-        [ response[:reference_number], request[:CardLastFourDigits], request[:Amount] ].join("|")
+        [response[:reference_number], request[:CardLastFourDigits], request[:Amount]].join('|')
       end
 
       def split_authorization(authorization)
-        reference_number, last_four_digits, original_amount = authorization.split("|")
+        reference_number, last_four_digits, original_amount = authorization.split('|')
         [reference_number, last_four_digits, original_amount]
       end
 
@@ -275,14 +275,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def cvv_result_code(xml)
-        cvv = validation_result_element(xml, "CVV")
+        cvv = validation_result_element(xml, 'CVV')
         return nil unless cvv
+
         validation_result_matches?(*validation_result_element_text(cvv.parent)) ? 'M' : 'N'
       end
 
       def avs_result_code(xml)
-        billing_address_elem = validation_result_element(xml, "Billing Address")
-        zip_code_elem = validation_result_element(xml, "Zip Code")
+        billing_address_elem = validation_result_element(xml, 'Billing Address')
+        zip_code_elem = validation_result_element(xml, 'Zip Code')
 
         return nil unless billing_address_elem && zip_code_elem
 
@@ -312,10 +313,10 @@ module ActiveMerchant #:nodoc:
 
       def validation_result_element_text(element)
         result_text = element.elements.detect { |elem|
-          elem.name == "Result"
-        }.children.detect { |elem| elem.text }.text
+          elem.name == 'Result'
+        }.children.detect(&:text).text
 
-        result_text.split(";").collect(&:strip)
+        result_text.split(';').collect(&:strip)
       end
 
       def validation_result_matches?(present, match)

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

@@ -7,8 +7,8 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'USD'
       self.money_format = :cents
 
-      self.supported_countries = ['AD', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+      self.supported_countries = %w[AD AT BE BG CH CY CZ DE DK EE ES FO FI FR GB GI GL GR HR HU IE IS IL IT LI LT LU LV MC MT NL NO PL PT RO SE SI SM SK SJ TR VA]
+      self.supported_cardtypes = %i[visa master american_express diners_club]
 
       self.homepage_url = 'https://www.checkout.com/'
       self.display_name = 'Checkout.com'
@@ -83,7 +83,7 @@ module ActiveMerchant #:nodoc:
         end
       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) }
@@ -107,9 +107,7 @@ module ActiveMerchant #:nodoc:
         xml.bill_cc_ payment_method.number
         xml.bill_expmonth_ format(payment_method.month, :two_digits)
         xml.bill_expyear_ format(payment_method.year, :four_digits)
-        if payment_method.verification_value?
-          xml.bill_cvv2_ payment_method.verification_value
-        end
+        xml.bill_cvv2_ payment_method.verification_value if payment_method.verification_value?
       end
 
       def add_billing_info(xml, options)
@@ -125,13 +123,13 @@ module ActiveMerchant #:nodoc:
 
       def add_shipping_info(xml, options)
         if options[:shipping_address]
-          xml.ship_address_   options[:shipping_address][:address1]
-          xml.ship_address2_  options[:shipping_address][:address2]
-          xml.ship_city_    options[:shipping_address][:city]
-          xml.ship_state_   options[:shipping_address][:state]
-          xml.ship_postal_  options[:shipping_address][:zip]
-          xml.ship_country_   options[:shipping_address][:country]
-          xml.ship_phone_   options[:shipping_address][:phone]
+          xml.ship_address_  options[:shipping_address][:address1]
+          xml.ship_address2_ options[:shipping_address][:address2]
+          xml.ship_city_     options[:shipping_address][:city]
+          xml.ship_state_    options[:shipping_address][:state]
+          xml.ship_postal_   options[:shipping_address][:zip]
+          xml.ship_country_  options[:shipping_address][:country]
+          xml.ship_phone_    options[:shipping_address][:phone]
         end
       end
 
@@ -144,7 +142,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_other_fields(xml, options)
-        xml.bill_email_   options[:email]
+        xml.bill_email_ options[:email]
         xml.bill_customerip_ options[:ip]
         xml.merchantcustomerid_ options[:customer]
         xml.descriptor_name options[:descriptor_name]
@@ -152,7 +150,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_reference(xml, authorization)
-        transid, trackid, _, _, _ = split_authorization(authorization)
+        transid, trackid, = split_authorization(authorization)
         xml.transid transid
         add_track_id(xml, trackid)
       end
@@ -161,11 +159,11 @@ module ActiveMerchant #:nodoc:
         xml.trackid(trackid) if trackid
       end
 
-      def commit(action, amount=nil, options={}, &builder)
+      def commit(action, amount = nil, options = {}, &builder)
         response = parse_xml(ssl_post(live_url, build_xml(action, &builder)))
         Response.new(
-          (response[:responsecode] == "0"),
-          (response[:result] || response[:error_text] || "Unknown Response"),
+          (response[:responsecode] == '0'),
+          (response[:result] || response[:error_text] || 'Unknown Response'),
           response,
           authorization: authorization_from(response, action, amount, options),
           test: test?
@@ -184,10 +182,10 @@ module ActiveMerchant #:nodoc:
       def parse_xml(xml)
         response = {}
 
-        Nokogiri::XML(CGI.unescapeHTML(xml)).xpath("//response").children.each do |node|
+        Nokogiri::XML(CGI.unescapeHTML(xml)).xpath('//response').children.each do |node|
           if node.text?
             next
-          elsif (node.elements.size == 0)
+          elsif node.elements.size == 0
             response[node.name.downcase.to_sym] = node.text
           else
             node.elements.each do |childnode|
@@ -200,13 +198,13 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      def authorization_from(response, action,  amount, options)
+      def authorization_from(response, action, amount, options)
         currency = options[:currency] || currency(amount)
-        [response[:tranid], response[:trackid], action, amount, currency].join("|")
+        [response[:tranid], response[:trackid], action, amount, currency].join('|')
       end
 
       def split_authorization(authorization)
-        transid, trackid, action, amount, currency = authorization.split("|")
+        transid, trackid, action, amount, currency = authorization.split('|')
         [transid, trackid, action, amount, currency]
       end
     end