activemerchant 1.133.0 → 1.138.0

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

@@ -1,8 +1,10 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class PinGateway < Gateway
-      self.test_url = 'https://test-api.pinpayments.com/1'
-      self.live_url = 'https://api.pinpayments.com/1'
+      version '1'
+
+      self.test_url = "https://test-api.pinpayments.com/#{fetch_version}"
+      self.live_url = "https://api.pinpayments.com/#{fetch_version}"
 
       self.default_currency = 'AUD'
       self.money_format = :cents
@@ -16,37 +18,38 @@ module ActiveMerchant #:nodoc:
         super
       end
 
-      # Create a charge using a credit card, card token or customer token
+      # Create a charge using a payment method, card token or customer token
       #
-      # To charge a credit card: purchase([money], [creditcard hash], ...)
+      # To charge a payment method: purchase([money], [payment_method hash], ...)
       # To charge a customer: purchase([money], [token], ...)
-      def purchase(money, creditcard, options = {})
+      def purchase(money, payment_method, options = {})
         post = {}
 
         add_amount(post, money, options)
         add_customer_data(post, options)
         add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, creditcard, options)
+        add_payment_method(post, payment_method)
+        add_address(post, payment_method, options)
         add_capture(post, options)
         add_metadata(post, options)
         add_3ds(post, options)
+        add_platform_adjustment(post, options)
 
         commit(:post, 'charges', post, options)
       end
 
-      # Create a customer and associated credit card. The token that is returned
-      # can be used instead of a credit card parameter in the purchase method
-      def store(creditcard, options = {})
+      # Create a customer and associated payment method. The token that is returned
+      # can be used instead of a payment method parameter in the purchase method
+      def store(payment_method, options = {})
         post = {}
 
-        add_creditcard(post, creditcard)
+        add_payment_method(post, payment_method)
         add_customer_data(post, options)
-        add_address(post, creditcard, options)
+        add_address(post, payment_method, options)
         commit(:post, 'customers', post, options)
       end
 
-      # Unstore a customer and associated credit card.
+      # Unstore a customer and associated payment method.
       def unstore(token)
         customer_token =
           if /cus_/.match?(token)
@@ -62,12 +65,12 @@ module ActiveMerchant #:nodoc:
         commit(:post, "charges/#{CGI.escape(token)}/refunds", { amount: amount(money) }, options)
       end
 
-      # Authorize an amount on a credit card. Once authorized, you can later
+      # Authorize an amount on a payment method. Once authorized, you can later
       # capture this charge using the charge token that is returned.
-      def authorize(money, creditcard, options = {})
+      def authorize(money, payment_method, options = {})
         options[:capture] = false
 
-        purchase(money, creditcard, options)
+        purchase(money, payment_method, options)
       end
 
       # Captures a previously authorized charge. Capturing only part of the original
@@ -81,14 +84,47 @@ module ActiveMerchant #:nodoc:
         commit(:put, "charges/#{CGI.escape(token)}/void", {}, options)
       end
 
-      # Updates the credit card for the customer.
-      def update(token, creditcard, options = {})
+      # Returns the details of a charge
+      def inquire(token, options = {})
+        commit(:get, "charges/#{CGI.escape(token)}", nil, options)
+      end
+
+      # Returns a paginated list of charges matching the search criteria.
+      # ==== Options:
+      # * <tt>:query </tt> -- (Optional) Return only charges whose fields match the query. Fields covered include description, email, metadata, cardholder name, currency, amount (exact), charge token (exact), card token (exact), refund token (exact), and customer token (exact).
+      # * <tt>:start_date </tt> -- (Optional) Return only charges created on or after this date (e.g. 2012/12/25).
+      # * <tt>:end_date </tt> -- (Optional) Return only charges created before this date (e.g. 2013/12/25).
+      # * <tt>:sort</tt> -- (Optional) The field used to sort the charges (created_at or amount). Default value is created_at.
+      # * <tt>:direction </tt> -- (Optional) The direction in which to sort the charges (1 for ascending or -1 for descending). Default value is 1.
+      #
+      def transaction_search(options = {})
+        params = {}
+        params[:query] = options[:query] if options[:query]
+        params[:start_date] = options[:start_date] if options[:start_date]
+        params[:end_date] = options[:end_date] if options[:end_date]
+        params[:sort] = options[:sort] if options[:sort]
+        params[:direction] = options[:direction] if options[:direction]
+        params[:page] = options[:page] if options[:page]
+
+        action = 'charges/search'
+        action += '?' + params.to_query unless params.empty?
+
+        commit(:get, action, nil, options)
+      end
+
+      # Verify a previously authorized charge.
+      def verify_3ds(session_token, options = {})
+        commit(:get, "/charges/verify?session_token=#{session_token}", nil, options)
+      end
+
+      # Updates the payment method for the customer.
+      def update(token, payment_method, options = {})
         post = {}
         token = get_customer_token(token)
 
-        add_creditcard(post, creditcard)
+        add_payment_method(post, payment_method)
         add_customer_data(post, options)
-        add_address(post, creditcard, options)
+        add_address(post, payment_method, options)
         commit(:put, "customers/#{CGI.escape(token)}", post, options)
       end
 
@@ -100,7 +136,8 @@ module ActiveMerchant #:nodoc:
         transcript.
           gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
           gsub(/(number\\?":\\?")(\d*)/, '\1[FILTERED]').
-          gsub(/(cvc\\?":\\?")(\d*)/, '\1[FILTERED]')
+          gsub(/(cvc\\?":\\?")(\d*)/, '\1[FILTERED]').
+          gsub(/(cryptogram\\?":\\?")(\w*)/, '\1[FILTERED]')
       end
 
       private
@@ -116,8 +153,8 @@ module ActiveMerchant #:nodoc:
         post[:ip_address] = options[:ip] if options[:ip]
       end
 
-      def add_address(post, creditcard, options)
-        return if creditcard.kind_of?(String)
+      def add_address(post, payment_method, options)
+        return if payment_method.kind_of?(String) || payment_method.kind_of?(NetworkTokenizationCreditCard)
 
         address = (options[:billing_address] || options[:address])
         return unless address
@@ -143,26 +180,51 @@ module ActiveMerchant #:nodoc:
         post[:capture] = capture != false
       end
 
-      def add_creditcard(post, creditcard)
-        if creditcard.respond_to?(:number)
-          post[:card] ||= {}
+      def add_payment_method(post, payment_method)
+        return unless payment_method
 
+        case payment_method
+        when NetworkTokenizationCreditCard
+          get_token = get_single_use_token(payment_method, options)
+          post[:payment_source_token] = get_token.params.dig('response', 'token')
+        when CreditCard
+          post[:card] ||= {}
           post[:card].merge!(
-            number: creditcard.number,
-            expiry_month: creditcard.month,
-            expiry_year: creditcard.year,
-            cvc: creditcard.verification_value,
-            name: creditcard.name
+            number: payment_method.number,
+            expiry_month: payment_method.month,
+            expiry_year: payment_method.year,
+            cvc: payment_method.verification_value,
+            name: payment_method.name
           )
-        elsif creditcard.kind_of?(String)
-          if /^card_/.match?(creditcard)
-            post[:card_token] = get_card_token(creditcard)
+        when String
+          if /^card_/.match?(payment_method)
+            post[:card_token] = get_card_token(payment_method)
           else
-            post[:customer_token] = creditcard
+            post[:customer_token] = payment_method
           end
+        else
+          raise ArgumentError, "Invalid payment method type: #{payment_method.class}"
         end
       end
 
+      # Get a single use token from Pin for NT based payment methods
+      # This is used to create a charge using a network tokenized card
+      def get_single_use_token(payment_method, options)
+        post = {
+          type: 'network_token',
+          source: {
+            number: payment_method.number,
+            expiry_month: payment_method.month,
+            expiry_year: payment_method.year,
+            network_type: payment_method.source.to_s.gsub('_', ''),
+            cryptogram: payment_method.payment_cryptogram,
+            eci: payment_method.eci
+          }
+        }
+
+        commit(:post, 'payment_sources', post, options)
+      end
+
       def get_customer_token(token)
         token.split(/;(?=cus)/).last
       end
@@ -175,13 +237,23 @@ module ActiveMerchant #:nodoc:
         post[:metadata] = options[:metadata] if options[:metadata]
       end
 
+      def add_platform_adjustment(post, options)
+        post[:platform_adjustment] = options[:platform_adjustment] if options[:platform_adjustment]
+      end
+
       def add_3ds(post, options)
         if options[:three_d_secure]
           post[:three_d_secure] = {}
-          post[:three_d_secure][:version] = options[:three_d_secure][:version] if options[:three_d_secure][:version]
-          post[:three_d_secure][:eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
-          post[:three_d_secure][:cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
-          post[:three_d_secure][:transaction_id] = options[:three_d_secure][:ds_transaction_id] || options[:three_d_secure][:xid]
+          if options[:three_d_secure][:enabled]
+            post[:three_d_secure][:enabled] = true
+            post[:three_d_secure][:fallback_ok] = options[:three_d_secure][:fallback_ok] unless options[:three_d_secure][:fallback_ok].nil?
+            post[:three_d_secure][:callback_url] = options[:three_d_secure][:callback_url] if options[:three_d_secure][:callback_url]
+          else
+            post[:three_d_secure][:version] = options[:three_d_secure][:version] if options[:three_d_secure][:version]
+            post[:three_d_secure][:eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+            post[:three_d_secure][:cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+            post[:three_d_secure][:transaction_id] = options[:three_d_secure][:ds_transaction_id] || options[:three_d_secure][:xid]
+          end
         end
       end
 
@@ -208,6 +280,8 @@ module ActiveMerchant #:nodoc:
 
         if body.nil?
           no_content_response
+        elsif body['response'].is_a?(Array)
+          paginated_response(body)
         elsif body['response']
           success_response(body)
         elsif body['error']
@@ -253,6 +327,15 @@ module ActiveMerchant #:nodoc:
         return Response.new(false, message)
       end
 
+      def paginated_response(body)
+        Response.new(
+          true,
+          'Search successful',
+          body,
+          test: test?
+        )
+      end
+
       def token(response)
         if response['token'].start_with?('cus')
           "#{response.dig('card', 'token')};#{response['token']}"
@@ -266,6 +349,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def post_data(parameters = {})
+        return nil unless parameters
+
         parameters.to_json
       end
     end

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

@@ -1,8 +1,10 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class PlexoGateway < Gateway
-      self.test_url = 'https://api.testing.plexo.com.uy/v1/payments'
-      self.live_url = 'https://api.plexo.com.uy/v1/payments'
+      version 'v1'
+
+      self.test_url = "https://api.testing.plexo.com.uy/#{fetch_version}/payments"
+      self.live_url = "https://api.plexo.com.uy/#{fetch_version}/payments"
 
       self.supported_countries = ['UY']
       self.default_currency = 'UYU'
@@ -44,6 +46,11 @@ module ActiveMerchant #:nodoc:
         commit("/#{authorization}/captures", post, options)
       end
 
+      def inquire(authorization, options = {})
+        post = { payment_id: authorization }
+        commit('status', post, options)
+      end
+
       def refund(money, authorization, options = {})
         post = {}
         post[:ReferenceId] = options[:reference_id] || generate_unique_id
@@ -67,6 +74,7 @@ module ActiveMerchant #:nodoc:
       def verify(credit_card, options = {})
         post = {}
         post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:Flow] = 'direct'
         post[:MerchantId] = options[:merchant_id] || @credentials[:merchant_id]
         post[:StatementDescriptor] = options[:statement_descriptor] if options[:statement_descriptor]
         post[:CustomerId] = options[:customer_id] if options[:customer_id]
@@ -76,6 +84,7 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options[:metadata])
         add_amount(money, post, options)
         add_browser_details(post, options)
+        add_invoice_number(post, options)
 
         commit('/verify', post, options)
       end
@@ -90,7 +99,8 @@ module ActiveMerchant #:nodoc:
           gsub(%r(("Number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
           gsub(%r(("Cvc\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
           gsub(%r(("InvoiceNumber\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
-          gsub(%r(("MerchantId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+          gsub(%r(("MerchantId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("Cryptogram\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
       end
 
       private
@@ -105,12 +115,14 @@ module ActiveMerchant #:nodoc:
         post[:Installments] = options[:installments] if options[:installments]
         post[:StatementDescriptor] = options[:statement_descriptor] if options[:statement_descriptor]
         post[:CustomerId] = options[:customer_id] if options[:customer_id]
+        post[:Flow] = 'direct'
 
         add_payment_method(post, payment, options)
         add_items(post, options[:items])
         add_metadata(post, options[:metadata])
         add_amount(money, post, options)
         add_browser_details(post, options)
+        add_invoice_number(post, options)
       end
 
       def header(parameters = {})
@@ -186,18 +198,42 @@ module ActiveMerchant #:nodoc:
         post[:BrowserDetails][:IpAddress] = browser_details[:ip] if browser_details[:ip]
       end
 
+      def add_invoice_number(post, options)
+        post[:InvoiceNumber] = options[:invoice_number] if options[:invoice_number]
+      end
+
       def add_payment_method(post, payment, options)
-        post[:paymentMethod] = {}
+        payment_method = build_payment_method(payment)
 
-        if payment&.is_a?(CreditCard)
-          post[:paymentMethod][:type] = 'card'
-          post[:paymentMethod][:Card] = {}
-          post[:paymentMethod][:Card][:Number] = payment.number
-          post[:paymentMethod][:Card][:ExpMonth] = format(payment.month, :two_digits) if payment.month
-          post[:paymentMethod][:Card][:ExpYear] = format(payment.year, :two_digits) if payment.year
-          post[:paymentMethod][:Card][:Cvc] = payment.verification_value if payment.verification_value
+        if payment_method.present?
+          add_card_holder(payment_method[:NetworkToken] || payment_method[:Card], payment, options)
+          post[:paymentMethod] = payment_method
+        end
+      end
 
-          add_card_holder(post[:paymentMethod][:Card], payment, options)
+      def build_payment_method(payment)
+        case payment
+        when NetworkTokenizationCreditCard
+          {
+            source: 'network-token',
+            id: payment.brand,
+            NetworkToken: {
+              Number: payment.number,
+              ExpMonth: (format(payment.month, :two_digits) if payment.month),
+              ExpYear: (format(payment.year, :two_digits) if payment.year),
+              Cryptogram: payment.payment_cryptogram
+            }
+          }
+        when CreditCard
+          {
+            type: 'card',
+            Card: {
+              Number: payment.number,
+              ExpMonth: (format(payment.month, :two_digits) if payment.month),
+              ExpYear: (format(payment.year, :two_digits) if payment.year),
+              Cvc: payment.verification_value
+            }
+          }
         end
       end
 
@@ -235,8 +271,11 @@ module ActiveMerchant #:nodoc:
         JSON.parse(body)
       end
 
-      def build_url(action, base)
-        url = base
+      def build_url(action, options, parameters)
+        base_url = test? ? test_url : live_url
+        return "#{base_url}/#{parameters[:payment_id]}" if action == 'status' && parameters[:payment_id]
+
+        url = base_url
         url += action if APPENDED_URLS.any? { |key| action.include?(key) }
         url
       end
@@ -256,10 +295,12 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters, options = {})
-        base_url = (test? ? test_url : live_url)
-        url = build_url(action, base_url)
-        response = parse(ssl_post(url, parameters.to_json, header(options)))
-        response = reorder_amount_fields(response) if AMOUNT_IN_RESPONSE.include?(action)
+        url = build_url(action, options, parameters)
+
+        raw = make_request(action, url, parameters, options)
+        response = parse(raw)
+
+        reorder_amount_fields(response) if AMOUNT_IN_RESPONSE.include?(action)
 
         Response.new(
           success_from(response),
@@ -271,6 +312,16 @@ module ActiveMerchant #:nodoc:
         )
       end
 
+      def make_request(action, url, parameters, options)
+        if action == 'status'
+          ssl_get(url, header(options))
+        else
+          ssl_post(url, parameters.to_json, header(options))
+        end
+      rescue ResponseError => e
+        e.response.body
+      end
+
       def handle_response(response)
         case response.code.to_i
         when 200...300, 400, 401

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

@@ -178,11 +178,15 @@ module ActiveMerchant
         success = SUCCESS_CODES.include?(response[:finalstatus])
         message = success ? 'Success' : message_from(response)
 
-        Response.new(success, message, response,
+        Response.new(
+          success,
+          message,
+          response,
           test: test?,
           authorization: response[:orderid],
           avs_result: { code: response[:avs_code] },
-          cvv_result: response[:cvvresp])
+          cvv_result: response[:cvvresp]
+        )
       end
 
       def parse(body)

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

@@ -1,23 +1,27 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class PriorityGateway < Gateway
+      version 'v3'
+      version 'v1', :verify_card_api
+      version 'v1', :jwt_api
+
       # Sandbox and Production
-      self.test_url = 'https://sandbox.api.mxmerchant.com/checkout/v3/payment'
-      self.live_url = 'https://api.mxmerchant.com/checkout/v3/payment'
+      self.test_url = "https://sandbox.api.mxmerchant.com/checkout/#{fetch_version}/payment"
+      self.live_url = "https://api.mxmerchant.com/checkout/#{fetch_version}/payment"
 
       class_attribute :test_url_verify, :live_url_verify, :test_auth, :live_auth, :test_env_verify, :live_env_verify, :test_url_batch, :live_url_batch, :test_url_jwt, :live_url_jwt, :merchant
 
       # Sandbox and Production - verify card
-      self.test_url_verify = 'https://sandbox-api2.mxmerchant.com/merchant/v1/bin'
-      self.live_url_verify = 'https://api2.mxmerchant.com/merchant/v1/bin'
+      self.test_url_verify = "https://sandbox-api2.mxmerchant.com/merchant/#{fetch_version(:verify_card_api)}/bin"
+      self.live_url_verify = "https://api2.mxmerchant.com/merchant/#{fetch_version(:verify_card_api)}/bin"
 
       # Sandbox and Production - check batch status
-      self.test_url_batch = 'https://sandbox.api.mxmerchant.com/checkout/v3/batch'
-      self.live_url_batch = 'https://api.mxmerchant.com/checkout/v3/batch'
+      self.test_url_batch = "https://sandbox.api.mxmerchant.com/checkout/#{fetch_version}/batch"
+      self.live_url_batch = "https://api.mxmerchant.com/checkout/#{fetch_version}/batch"
 
       # Sandbox and Production - generate jwt for verify card url
-      self.test_url_jwt = 'https://sandbox-api2.mxmerchant.com/security/v1/application/merchantId'
-      self.live_url_jwt = 'https://api2.mxmerchant.com/security/v1/application/merchantId'
+      self.test_url_jwt = "https://sandbox-api2.mxmerchant.com/security/#{fetch_version(:jwt_api)}/application/merchantId"
+      self.live_url_jwt = "https://api2.mxmerchant.com/security/#{fetch_version(:jwt_api)}/application/merchantId"
 
       self.supported_countries = ['US']
       self.default_currency = 'USD'
@@ -55,9 +59,10 @@ module ActiveMerchant #:nodoc:
 
         add_merchant_id(params)
         add_amount(params, amount, options)
-        add_auth_purchase_params(params, credit_card, options)
+        add_auth_purchase_params(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
 
-        commit('purchase', params: params)
+        commit('purchase', params:)
       end
 
       def authorize(amount, credit_card, options = {})
@@ -67,9 +72,10 @@ module ActiveMerchant #:nodoc:
 
         add_merchant_id(params)
         add_amount(params, amount, options)
-        add_auth_purchase_params(params, credit_card, options)
+        add_auth_purchase_params(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
 
-        commit('purchase', params: params)
+        commit('purchase', params:)
       end
 
       def credit(amount, credit_card, options = {})
@@ -81,7 +87,7 @@ module ActiveMerchant #:nodoc:
         add_merchant_id(params)
         add_amount(params, amount, options)
         add_credit_params(params, credit_card, options)
-        commit('credit', params: params)
+        commit('credit', params:)
       end
 
       def refund(amount, authorization, options = {})
@@ -92,7 +98,7 @@ module ActiveMerchant #:nodoc:
         # refund amounts must be negative
         params['amount'] = ('-' + localized_amount(amount.to_f, options[:currency])).to_f
 
-        commit('refund', params: params)
+        commit('refund', params:)
       end
 
       def capture(amount, authorization, options = {})
@@ -100,21 +106,21 @@ module ActiveMerchant #:nodoc:
         add_merchant_id(params)
         add_amount(params, amount, options)
         params['paymentToken'] = payment_token(authorization) || options[:payment_token]
-        params['tenderType'] = options[:tender_type].present? ? options[:tender_type] : 'Card'
+        add_auth_purchase_params(params, options)
 
-        commit('capture', params: params)
+        commit('capture', params:)
       end
 
       def void(authorization, options = {})
         params = {}
 
-        commit('void', params: params, iid: payment_id(authorization))
+        commit('void', params:, iid: payment_id(authorization))
       end
 
       def verify(credit_card, _options = {})
         jwt = create_jwt.params['jwtToken']
 
-        commit('verify', card_number: credit_card.number, jwt: jwt)
+        commit('verify', card_number: credit_card.number, jwt:)
       end
 
       def get_payment_status(batch_id)
@@ -150,9 +156,8 @@ module ActiveMerchant #:nodoc:
         params['merchantId'] = @options[:merchant_id]
       end
 
-      def add_auth_purchase_params(params, credit_card, options)
+      def add_auth_purchase_params(params, options)
         add_replay_id(params, options)
-        add_credit_card(params, credit_card, 'purchase', options)
         add_purchases_data(params, options)
         add_shipping_data(params, options)
         add_pos_data(params, options)
@@ -314,7 +319,7 @@ module ActiveMerchant #:nodoc:
         when 'void'
           base_url + "/#{ref_number}?force=true"
         when 'verify'
-          (verify_url + '?search=') + credit_card_number.to_s[0..6]
+          (verify_url + '?search=') + credit_card_number.to_s[0..7]
         when 'get_payment_status', 'close_batch'
           batch_url + "/#{params}"
         when 'create_jwt'
@@ -365,7 +370,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def success_from(response, action)
-        return !response['bank'].empty? if action == 'verify' && response['bank']
+        return !response['bank'].empty? if action == 'verify' && response['bank'] && !response.dig('bank', 'name').blank?
 
         %w[Approved Open Success Settled Voided].include?(response['status'])
       end

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

@@ -1,7 +1,7 @@
 require 'nokogiri'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class ProPayGateway < Gateway
       self.test_url = 'https://xmltest.propay.com/API/PropayAPI.aspx'
       self.live_url = 'https://epay.propay.com/api/propayapi.aspx'

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

@@ -1,7 +1,7 @@
 require 'rexml/document'
 
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     # This class implements the Psigate gateway for the ActiveMerchant module.
     #
     # Modifications by Sean O'Hara ( sohara at sohara dot com )
@@ -102,11 +102,15 @@ module ActiveMerchant #:nodoc:
       def commit(money, creditcard, options = {})
         response = parse(ssl_post(url, post_data(money, creditcard, options)))
 
-        Response.new(successful?(response), message_from(response), response,
+        Response.new(
+          successful?(response),
+          message_from(response),
+          response,
           test: test?,
           authorization: build_authorization(response),
           avs_result: { code: response[:avsresult] },
-          cvv_result: response[:cardidresult])
+          cvv_result: response[:cardidresult]
+        )
       end
 
       def url

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

@@ -259,11 +259,15 @@ module ActiveMerchant
       def commit(request)
         response = parse(ssl_post(self.live_url, post_data(request)))
 
-        Response.new(response[:ResponseCode] == APPROVED, response[:Message], response,
+        Response.new(
+          response[:ResponseCode] == APPROVED,
+          response[:Message],
+          response,
           test: test?,
           authorization: response[:CrossReference],
           cvv_result: CVV_CODE[response[:AVSCV2Check]],
-          avs_result: { code: AVS_CODE[response[:AVSCV2Check]] })
+          avs_result: { code: AVS_CODE[response[:AVSCV2Check]] }
+        )
       end
 
       # Put the passed data into a format that can be submitted to PSL