activemerchant 1.42.6 → 1.90.0

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

@@ -0,0 +1,264 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SecurionPayGateway < Gateway
+      self.test_url = 'https://api.securionpay.com/'
+      self.live_url = 'https://api.securionpay.com/'
+
+      self.supported_countries = %w(AL AD AT BY BE BG HR CY CZ RE DK EE IS FI FR DE GI GR HU IS IE IT IL LV LI LT LU
+                                    MK MT MD MC NL NO PL PT RO RU MA RS SK SI ES SE CH UA GB KI CI ME)
+
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = 'https://securionpay.com/'
+      self.display_name = 'SecurionPay'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        'incorrect_number' => STANDARD_ERROR_CODE[:incorrect_number],
+        'invalid_number' => STANDARD_ERROR_CODE[:invalid_number],
+        'invalid_expiry_month' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'invalid_expiry_year' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'invalid_cvc' => STANDARD_ERROR_CODE[:invalid_cvc],
+        'expired_card' => STANDARD_ERROR_CODE[:expired_card],
+        'insufficient_funds' => STANDARD_ERROR_CODE[:card_declined],
+        'incorrect_cvc' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        'incorrect_zip' => STANDARD_ERROR_CODE[:incorrect_zip],
+        'card_declined' => STANDARD_ERROR_CODE[:card_declined],
+        'processing_error' => STANDARD_ERROR_CODE[:processing_error],
+        'lost_or_stolen' => STANDARD_ERROR_CODE[:card_declined],
+        'suspected_fraud' => STANDARD_ERROR_CODE[:card_declined],
+        'expired_token' => STANDARD_ERROR_CODE[:card_declined]
+      }
+
+      def initialize(options={})
+        requires!(options, :secret_key)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = create_post_for_auth_or_purchase(money, payment, options)
+        commit('charges', post, options)
+      end
+
+      def authorize(money, payment, options={})
+        post = create_post_for_auth_or_purchase(money, payment, options)
+        post[:captured] = 'false'
+        commit('charges', post, options)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money, options)
+        commit("charges/#{CGI.escape(authorization)}/capture", post, options)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        add_amount(post, money, options)
+        commit("charges/#{CGI.escape(authorization)}/refund", post, options)
+      end
+
+      def void(authorization, options = {})
+        commit("charges/#{CGI.escape(authorization)}/refund", {}, options)
+      end
+
+      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) }
+        end
+      end
+
+      def store(credit_card, options = {})
+        if options[:customer_id].blank?
+          MultiResponse.run() do |r|
+            # create charge object
+            r.process { authorize(100, credit_card, options) }
+            # create customer and save card
+            r.process { create_customer_add_card(r.authorization, options) }
+            # void the charge
+            r.process(:ignore_result) { void(r.params['metadata']['chargeId'], options) }
+          end
+        else
+          verify(credit_card, options)
+        end
+      end
+
+      def customer(options = {})
+        if options[:customer_id].blank?
+          return nil
+        else
+          commit("customers/#{CGI.escape(options[:customer_id])}", nil, options, :get)
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((card\[number\]=)\d+), '\1[FILTERED]').
+          gsub(%r((card\[cvc\]=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def create_customer_add_card(authorization, options)
+        post = {}
+        post[:email] = options[:email]
+        post[:description] = options[:description]
+        post[:card] = authorization
+        post[:metadata] = {}
+        post[:metadata][:chargeId] = authorization
+        commit('customers', post, options)
+      end
+
+      def add_customer(post, payment, options)
+        post[:customerId] = options[:customer_id] if options[:customer_id]
+      end
+
+      def add_customer_data(post, options)
+        post[:description] = options[:description]
+        post[:ip] =          options[:ip]
+        post[:user_agent] =  options[:user_agent]
+        post[:referrer] =    options[:referrer]
+      end
+
+      def create_post_for_auth_or_purchase(money, payment, options)
+        post = {}
+        add_amount(post, money, options, true)
+        add_creditcard(post, payment, options)
+        add_customer(post, payment, options)
+        add_customer_data(post, options)
+        if options[:email]
+          post[:metadata] = {}
+          post[:metadata][:email] = options[:email]
+        end
+        post
+      end
+
+      def add_amount(post, money, options, include_currency = false)
+        currency = (options[:currency] || default_currency)
+        post[:amount] = localized_amount(money, currency)
+        post[:currency] = currency.downcase if include_currency
+      end
+
+      def add_creditcard(post, creditcard, options)
+        card = {}
+        if creditcard.respond_to?(:number)
+          card[:number] = creditcard.number
+          card[:expMonth] = creditcard.month
+          card[:expYear] = creditcard.year
+          card[:cvc] = creditcard.verification_value if creditcard.verification_value?
+          card[:cardholderName] = creditcard.name if creditcard.name
+
+          post[:card] = card
+          add_address(post, options)
+        elsif creditcard.kind_of?(String)
+          post[:card] = creditcard
+        else
+          raise ArgumentError.new("Unhandled payment method #{creditcard.class}.")
+        end
+      end
+
+      def add_address(post, options)
+        return unless post[:card]&.kind_of?(Hash)
+        if address = options[:billing_address]
+          post[:card][:addressLine1] = address[:address1] if address[:address1]
+          post[:card][:addressLine2] = address[:address2] if address[:address2]
+          post[:card][:addressCountry] = address[:country] if address[:country]
+          post[:card][:addressZip] = address[:zip] if address[:zip]
+          post[:card][:addressState] = address[:state] if address[:state]
+          post[:card][:addressCity] = address[:city] if address[:city]
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(url, parameters = nil, options = {}, method = nil)
+        response = api_request(url, parameters, options, method)
+        success = !response.key?('error')
+
+        Response.new(success,
+          (success ? 'Transaction approved' : response['error']['message']),
+          response,
+          test: test?,
+          authorization: (success ? response['id'] : response['error']['charge']),
+          error_code: (success ? nil : STANDARD_ERROR_CODE_MAPPING[response['error']['code']])
+        )
+      end
+
+      def headers(options = {})
+        secret_key = options[:secret_key] || @options[:secret_key]
+
+        headers = {
+          'Authorization' => 'Basic ' + Base64.encode64(secret_key.to_s + ':').strip,
+          'User-Agent' => "SecurionPay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+        }
+        headers
+      end
+
+      def response_error(raw_response)
+        parse(raw_response)
+      rescue JSON::ParserError
+        json_error(raw_response)
+      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|
+              h["#{key}[#{k}]"] = v unless v.blank?
+            end
+            post_data(h)
+          elsif value.is_a?(Array)
+            value.map { |v| "#{key}[]=#{CGI.escape(v.to_s)}" }.join('&')
+          else
+            "#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end.compact.join('&')
+      end
+
+      def api_request(endpoint, parameters = nil, options = {}, method = nil)
+        raw_response = response = nil
+        begin
+          if method.blank?
+            raw_response = ssl_post(self.live_url + endpoint, post_data(parameters), headers(options))
+          else
+            raw_response = ssl_request(method, self.live_url + endpoint, post_data(parameters), headers(options))
+          end
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = response_error(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+        response
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response received from the SecurionPay API.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          'error' => {
+            'message' => msg
+          }
+        }
+      end
+
+      def test?
+        (@options[:secret_key]&.include?('_test_'))
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-#!ruby19
 # encoding: utf-8
 
 module ActiveMerchant #:nodoc:
@@ -6,11 +5,11 @@ module ActiveMerchant #:nodoc:
     class SkipJackGateway < Gateway
       API_VERSION = '?.?'
 
-      self.live_url = "https://www.skipjackic.com"
-      self.test_url = "https://developer.skipjackic.com"
+      self.live_url = 'https://www.skipjackic.com'
+      self.test_url = 'https://developer.skipjackic.com'
 
-      BASIC_PATH = "/scripts/evolvcc.dll"
-      ADVANCED_PATH = "/evolvcc/evolvcc.aspx"
+      BASIC_PATH = '/scripts/evolvcc.dll'
+      ADVANCED_PATH = '/evolvcc/evolvcc.aspx'
 
       ACTIONS = {
         :authorization => 'AuthorizeAPI',
@@ -25,35 +24,34 @@ module ActiveMerchant #:nodoc:
       CARD_CODE_ERRORS = %w( N S "" )
 
       CARD_CODE_MESSAGES = {
-        "M" => "Card verification number matched",
-        "N" => "Card verification number didn't match",
-        "P" => "Card verification number was not processed",
-        "S" => "Card verification number should be on card but was not indicated",
-        "U" => "Issuer was not certified for card verification",
-        "" => "Transaction failed because incorrect card verification number was entered or no number was entered"
+        'M' => 'Card verification number matched',
+        'N' => "Card verification number didn't match",
+        'P' => 'Card verification number was not processed',
+        'S' => 'Card verification number should be on card but was not indicated',
+        'U' => 'Issuer was not certified for card verification',
+        '' => 'Transaction failed because incorrect card verification number was entered or no number was entered'
       }
 
       AVS_ERRORS = %w( A B C E I N O P R W Z )
 
       AVS_MESSAGES = {
-        "A" => "Street address matches billing information, zip/postal code does not",
-        "B" => "Street address match for international transaction. Postal code not verified due to incompatible formats",
-        "C" => "Street address and postal code not verified for internation transaction due to incompatible formats",
-        "D" => "Street address and postal code match for international transaction",
-        "E" => "Address verification service error",
-        "I" => "Address information not verified by international issuer",
-        "M" => "Street address and postal code match for international transaction",
-        "N" => "Neither street address nor zip/postal match billing information",
-        "O" => "Non-US issuer does not participate",
-        "P" => "Postal codes match for international transaction but street address not verified due to incompatible formats",
-        "P" => "Address verification not applicable for this transaction",
-        "R" => "Payment gateway was unavailable or timed out",
-        "S" => "Address verification service not supported by issuer",
-        "U" => "Address information is unavailable",
-        "W" => "9-digit zip/postal code matches billing information, street address does not",
-        "X" => "Street address and 9-digit zip/postal code matches billing information",
-        "Y" => "Street address and 5-digit zip/postal code matches billing information",
-        "Z" => "5-digit zip/postal code matches billing information, street address does not",
+        'A' => 'Street address matches billing information, zip/postal code does not',
+        'B' => 'Street address match for international transaction. Postal code not verified due to incompatible formats',
+        'C' => 'Street address and postal code not verified for internation transaction due to incompatible formats',
+        'D' => 'Street address and postal code match for international transaction',
+        'E' => 'Address verification service error',
+        'I' => 'Address information not verified by international issuer',
+        'M' => 'Street address and postal code match for international transaction',
+        'N' => 'Neither street address nor zip/postal match billing information',
+        'O' => 'Non-US issuer does not participate',
+        'P' => 'Postal codes match for international transaction but street address not verified due to incompatible formats',
+        'R' => 'Payment gateway was unavailable or timed out',
+        'S' => 'Address verification service not supported by issuer',
+        'U' => 'Address information is unavailable',
+        'W' => '9-digit zip/postal code matches billing information, street address does not',
+        'X' => 'Street address and 9-digit zip/postal code matches billing information',
+        'Y' => 'Street address and 5-digit zip/postal code matches billing information',
+        'Z' => '5-digit zip/postal code matches billing information, street address does not',
       }
 
       CHANGE_STATUS_ERROR_MESSAGES = {
@@ -195,7 +193,6 @@ module ActiveMerchant #:nodoc:
       end
 
       def purchase(money, creditcard, options = {})
-        post = {}
         authorization = authorize(money, creditcard, options)
         if authorization.success?
           capture(money, authorization.authorization)
@@ -240,7 +237,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
@@ -263,7 +260,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, money, parameters)
-        response = parse( ssl_post( url_for(action), post_data(action, money, parameters) ), action )
+        response = parse(ssl_post(url_for(action), post_data(action, money, parameters)), action)
 
         # Pass along the original transaction id in the case an update transaction
         Response.new(response[:success], message_from(response, action), response,
@@ -277,7 +274,7 @@ module ActiveMerchant #:nodoc:
       def url_for(action)
         result = test? ? self.test_url : self.live_url
         result += advanced? && action == :authorization ? ADVANCED_PATH : BASIC_PATH
-        result += "?#{ACTIONS[action]}"
+        result + "?#{ACTIONS[action]}"
       end
 
       def add_credentials(params, action)
@@ -320,7 +317,7 @@ module ActiveMerchant #:nodoc:
       def authorize_response_map(body)
         lines = split_lines(body)
         keys, values = split_line(lines[0]), split_line(lines[1])
-        Hash[*(keys.zip(values).flatten)].symbolize_keys
+        Hash[*keys.zip(values).flatten].symbolize_keys
       end
 
       def parse_authorization_response(body)
@@ -335,7 +332,7 @@ module ActiveMerchant #:nodoc:
         keys = [ :szSerialNumber, :szErrorCode, :szNumberRecords]
         values = split_line(lines[0])[0..2]
 
-        result = Hash[*(keys.zip(values).flatten)]
+        result = Hash[*keys.zip(values).flatten]
 
         result[:szErrorMessage] = ''
         result[:success] = (result[:szErrorCode] == '0')
@@ -356,8 +353,8 @@ module ActiveMerchant #:nodoc:
       def post_data(action, money, params = {})
         add_credentials(params, action)
         add_amount(params, action, money)
-        sorted_params = params.to_a.sort{|a,b| a.to_s <=> b.to_s}.reverse
-        sorted_params.collect { |key, value| "#{key.to_s}=#{CGI.escape(value.to_s)}" }.join("&")
+        sorted_params = params.to_a.sort_by(&:to_s).reverse
+        sorted_params.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
       end
 
       def add_transaction_id(post, transaction_id)
@@ -371,7 +368,7 @@ module ActiveMerchant #:nodoc:
         post[:OrderDescription] = options[:description]
 
         if order_items = options[:items]
-          post[:OrderString] = order_items.collect { |item| "#{item[:sku]}~#{item[:description].tr('~','-')}~#{item[:declared_value]}~#{item[:quantity]}~#{item[:taxable]}~~~~~~~~#{item[:tax_rate]}~||"}.join
+          post[:OrderString] = order_items.collect { |item| "#{item[:sku]}~#{item[:description].tr('~', '-')}~#{item[:declared_value]}~#{item[:quantity]}~#{item[:taxable]}~~~~~~~~#{item[:tax_rate]}~||" }.join
         else
           post[:OrderString] = '1~None~0.00~0~N~||'
         end

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

@@ -23,9 +23,9 @@ module ActiveMerchant #:nodoc:
       def authorize(money, creditcard, options = {})
         post = {}
         add_invoice(post, options)
-        add_payment_source(post, creditcard,options)
+        add_payment_source(post, creditcard, options)
         add_address(post, options[:billing_address] || options[:address])
-        add_address(post, options[:shipping_address], "shipping")
+        add_address(post, options[:shipping_address], 'shipping')
         add_customer_data(post, options)
         add_currency(post, money, options)
         add_taxes(post, options)
@@ -38,11 +38,12 @@ module ActiveMerchant #:nodoc:
         add_invoice(post, options)
         add_payment_source(post, payment_source, options)
         add_address(post, options[:billing_address] || options[:address])
-        add_address(post, options[:shipping_address], "shipping")
+        add_address(post, options[:shipping_address], 'shipping')
         add_customer_data(post, options)
         add_currency(post, money, options)
         add_taxes(post, options)
         add_processor(post, options)
+        add_eci(post, options)
         commit('sale', money, post)
       end
 
@@ -64,7 +65,7 @@ module ActiveMerchant #:nodoc:
         add_payment_source(post, payment_source, options)
         add_address(post, options[:billing_address] || options[:address])
         add_customer_data(post, options)
-        add_sku(post,options)
+        add_sku(post, options)
         add_currency(post, money, options)
         add_processor(post, options)
         commit('credit', money, post)
@@ -76,13 +77,19 @@ module ActiveMerchant #:nodoc:
         commit('refund', money, post)
       end
 
+      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) }
+        end
+      end
 
       # Update the values (such as CC expiration) stored at
       # the gateway.  The CC number must be supplied in the
       # CreditCard object.
       def update(vault_id, creditcard, options = {})
         post = {}
-        post[:customer_vault] = "update_customer"
+        post[:customer_vault] = 'update_customer'
         add_customer_vault_id(post, vault_id)
         add_creditcard(post, creditcard, options)
         add_address(post, options[:billing_address] || options[:address])
@@ -99,10 +106,9 @@ module ActiveMerchant #:nodoc:
         commit('update', nil, post)
       end
 
-
       def delete(vault_id)
         post = {}
-        post[:customer_vault] = "delete_customer"
+        post[:customer_vault] = 'delete_customer'
         add_customer_vault_id(post, vault_id)
         commit(nil, nil, post)
       end
@@ -121,6 +127,7 @@ module ActiveMerchant #:nodoc:
       alias_method :unstore, :delete
 
       private
+
       def add_customer_data(post, options)
         if options.has_key? :email
           post[:email] = options[:email]
@@ -131,17 +138,17 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_address(post, address,prefix="")
-        prefix +="_" unless prefix.blank?
+      def add_address(post, address, prefix='')
+        prefix +='_' unless prefix.blank?
         unless address.blank? or address.values.blank?
-          post[prefix+"address1"]    = address[:address1].to_s
-          post[prefix+"address2"]    = address[:address2].to_s unless address[:address2].blank?
-          post[prefix+"company"]    = address[:company].to_s
-          post[prefix+"phone"]      = address[:phone].to_s
-          post[prefix+"zip"]        = address[:zip].to_s
-          post[prefix+"city"]       = address[:city].to_s
-          post[prefix+"country"]    = address[:country].to_s
-          post[prefix+"state"]      = address[:state].blank?  ? 'n/a' : address[:state]
+          post[prefix+'address1']    = address[:address1].to_s
+          post[prefix+'address2']    = address[:address2].to_s unless address[:address2].blank?
+          post[prefix+'company']    = address[:company].to_s
+          post[prefix+'phone']      = address[:phone].to_s
+          post[prefix+'zip']        = address[:zip].to_s
+          post[prefix+'city']       = address[:city].to_s
+          post[prefix+'country']    = address[:country].to_s
+          post[prefix+'state']      = address[:state].blank?  ? 'n/a' : address[:state]
         end
       end
 
@@ -175,7 +182,7 @@ module ActiveMerchant #:nodoc:
 
       def add_creditcard(post, creditcard, options)
         if options[:store]
-          post[:customer_vault] = "add_customer"
+          post[:customer_vault] = 'add_customer'
           post[:customer_vault_id] = options[:store] unless options[:store] == true
         end
         post[:ccnumber]  = creditcard.number
@@ -187,7 +194,7 @@ module ActiveMerchant #:nodoc:
 
       def add_check(post, check, options)
         if options[:store]
-          post[:customer_vault] = "add_customer"
+          post[:customer_vault] = 'add_customer'
           post[:customer_vault_id] = options[:store] unless options[:store] == true
         end
 
@@ -199,18 +206,22 @@ module ActiveMerchant #:nodoc:
         post[:account_type] = check.account_type # The customer's type of ACH account
       end
 
-      def add_sku(post,options)
-        post["product_sku_#"] = options[:sku] || options["product_sku_#"]
+      def add_sku(post, options)
+        post['product_sku_#'] = options[:sku] || options['product_sku_#']
       end
 
       def add_transaction(post, auth)
         post[:transactionid] = auth
       end
 
+      def add_eci(post, options)
+        post[:billing_method] = options[:eci] if options[:eci]
+      end
+
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
-          key,val = pair.split(/=/)
+          key, val = pair.split(/=/)
           results[key] = val
         end
 
@@ -218,33 +229,31 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, money, parameters)
-        parameters[:amount]  = amount(money) if money
-        response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
-        Response.new(response["response"] == "1", message_from(response), response,
-          :authorization => (response["transactionid"] || response["customer_vault_id"]),
+        parameters[:amount]  = localized_amount(money, parameters[:currency] || default_currency) if money
+        response = parse(ssl_post(self.live_url, post_data(action, parameters)))
+        Response.new(response['response'] == '1', message_from(response), response,
+          :authorization => (response['transactionid'] || response['customer_vault_id']),
           :test => test?,
-          :cvv_result => response["cvvresponse"],
-          :avs_result => { :code => response["avsresponse"] }
+          :cvv_result => response['cvvresponse'],
+          :avs_result => { :code => response['avsresponse'] }
         )
-
       end
 
       def expdate(creditcard)
-        year  = sprintf("%.04i", creditcard.year.to_i)
-        month = sprintf("%.02i", creditcard.month.to_i)
+        year  = sprintf('%.04i', creditcard.year)
+        month = sprintf('%.02i', creditcard.month)
 
         "#{month}#{year[-2..-1]}"
       end
 
-
       def message_from(response)
-        case response["responsetext"]
-        when "SUCCESS", "Approved", nil # This is dubious, but responses from UPDATE are nil.
-          "This transaction has been approved"
-        when "DECLINE"
-          "This transaction has been declined"
+        case response['responsetext']
+        when 'SUCCESS', 'Approved', nil # This is dubious, but responses from UPDATE are nil.
+          'This transaction has been approved'
+        when 'DECLINE'
+          'This transaction has been declined'
         else
-          response["responsetext"]
+          response['responsetext']
         end
       end
 
@@ -254,19 +263,18 @@ module ActiveMerchant #:nodoc:
         post[:password]   = @options[:password]
         post[:type]       = action if action
 
-        request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
+        request = post.merge(parameters).map { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
         request
       end
 
       def determine_funding_source(source)
         case
         when source.is_a?(String) then :vault
-        when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
+        when CreditCard.card_companies.include?(card_brand(source)) then :credit_card
         when card_brand(source) == 'check' then :check
-        else raise ArgumentError, "Unsupported funding source provided"
+        else raise ArgumentError, 'Unsupported funding source provided'
         end
       end
     end
   end
 end
-