inspire.rb in activemerchant-1.29.0

- old
+ new
@@ -1,215 +1,215 @@
 require File.join(File.dirname(__FILE__), '..', 'check.rb')
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class InspireGateway < Gateway
       self.live_url = self.test_url = 'https://secure.inspiregateway.net/api/transact.php'
-    
+
       self.supported_countries = ['US']
       self.supported_cardtypes = [:visa, :master, :american_express]
       self.homepage_url = 'http://www.inspiregateway.com'
       self.display_name = 'Inspire Commerce'
-      # Creates a new InspireGateway 
-      # 
+
+      # Creates a new InspireGateway
+      #
       # The gateway requires that a valid login and password be passed
       # in the +options+ hash.
-      # 
+      #
       # ==== Options
       #
       # * <tt>:login</tt> -- The Inspire Username.
       # * <tt>:password</tt> -- The Inspire Passowrd.
       # See the Inspire Integration Guide for details. (default: +false+)
       def initialize(options = {})
         requires!(options, :login, :password)
-        @options = options
         super
-      end  
-      
-      # Pass :store => true in the options to store the 
-      # payment info at Inspire Gateway and get a generated 
-      # customer_vault_id in the response.  
+      end
+
+      # Pass :store => true in the options to store the
+      # payment info at Inspire Gateway and get a generated
+      # customer_vault_id in the response.
       # Pass :store => some_number_or_string to specify the
       # customer_vault_id InspireGateway should use (make sure it's
       # unique).
       def authorize(money, creditcard, options = {})
         post = {}
         add_invoice(post, options)
-        add_payment_source(post, creditcard,options)        
-        add_address(post, creditcard, options)        
+        add_payment_source(post, creditcard,options)
+        add_address(post, creditcard, options)
         add_customer_data(post, options)
-        
+
         commit('auth', money, post)
       end
-      
+
       def purchase(money, payment_source, options = {})
         post = {}
         add_invoice(post, options)
-        add_payment_source(post, payment_source, options)        
-        add_address(post, payment_source, options)   
+        add_payment_source(post, payment_source, options)
+        add_address(post, payment_source, options)
         add_customer_data(post, options)
-             
+
         commit('sale', money, post)
-      end                       
-    
+      end
+
       def capture(money, authorization, options = {})
         post ={}
         post[:transactionid] = authorization
         commit('capture', money, post)
       end
-      
+
       def void(authorization, options = {})
         post ={}
         post[:transactionid] = authorization
         commit('void', nil, post)
       end
-      
+
       # Update the values (such as CC expiration) stored at
       # InspireGateway.  The CC number must be supplied in the
       # CreditCard object.
       def update(vault_id, creditcard, options = {})
         post = {}
         post[:customer_vault] = "update_customer"
         add_customer_vault_id(post, vault_id)
-        add_creditcard(post, creditcard, options)        
-        add_address(post, creditcard, options)   
+        add_creditcard(post, creditcard, options)
+        add_address(post, creditcard, options)
         add_customer_data(post, options)
-             
+
         commit(nil, nil, post)
       end
-    
+
       def delete(vault_id)
         post = {}
         post[:customer_vault] = "delete_customer"
-        add_customer_vault_id(post, vault_id)         
+        add_customer_vault_id(post, vault_id)
         commit(nil, nil, post)
       end
-    
+
       # To match the other stored-value gateways, like TrustCommerce,
       # store and unstore need to be defined
       def store(creditcard, options = {})
         billing_id = options.delete(:billing_id).to_s || true
         authorize(100, creditcard, options.merge(:store => billing_id))
       end
-      
+
       alias_method :unstore, :delete
 
-      private                             
+      private
       def add_customer_data(post, options)
         if options.has_key? :email
           post[:email] = options[:email]
         end
 
         if options.has_key? :ip
           post[:ipaddress] = options[:ip]
-        end        
+        end
       end
 
-      def add_address(post, creditcard, options)     
+      def add_address(post, creditcard, options)
         if address = options[:billing_address] || options[:address]
           post[:address1]    = address[:address1].to_s
           post[:address2]    = address[:address2].to_s unless address[:address2].blank?
           post[:company]    = address[:company].to_s
           post[:phone]      = address[:phone].to_s
-          post[:zip]        = address[:zip].to_s       
+          post[:zip]        = address[:zip].to_s
           post[:city]       = address[:city].to_s
           post[:country]    = address[:country].to_s
           post[:state]      = address[:state].blank?  ? 'n/a' : address[:state]
-        end         
+        end
       end
 
       def add_invoice(post, options)
         post[:orderid] = options[:order_id].to_s.gsub(/[^\w.]/, '')
         post[:orderdescription] = options[:description]
       end
-      
+
       def add_payment_source(params, source, options={})
         case determine_funding_source(source)
         when :vault       then add_customer_vault_id(params, source)
         when :credit_card then add_creditcard(params, source, options)
         when :check       then add_check(params, source)
         end
       end
-      
+
       def add_customer_vault_id(params,vault_id)
         params[:customer_vault_id] = vault_id
       end
-      
+
       def add_creditcard(post, creditcard,options)
-        if options[:store]  
+        if options[:store]
           post[:customer_vault] = "add_customer"
           post[:customer_vault_id] = options[:store] unless options[:store] == true
         end
         post[:ccnumber]  = creditcard.number
         post[:cvv] = creditcard.verification_value if creditcard.verification_value?
         post[:ccexp]  = expdate(creditcard)
         post[:firstname] = creditcard.first_name
-        post[:lastname]  = creditcard.last_name   
+        post[:lastname]  = creditcard.last_name
       end
-      
+
       def add_check(post, check)
         post[:payment] = 'check' # Set transaction to ACH
         post[:checkname] = check.name # The name on the customer's Checking Account
         post[:checkaba] = check.routing_number # The customer's bank routing number
         post[:checkaccount] = check.account_number # The customer's account number
         post[:account_holder_type] = check.account_holder_type # The customer's type of ACH account
         post[:account_type] = check.account_type # The customer's type of ACH account
       end
-      
+
       def parse(body)
         results = {}
         body.split(/&/).each do |pair|
           key,val = pair.split(/=/)
           results[key] = val
         end
-        
+
         results
-      end     
-      
+      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, 
+        Response.new(response["response"] == "1", message_from(response), response,
           :authorization => response["transactionid"],
           :test => test?,
           :cvv_result => response["cvvresponse"],
           :avs_result => { :code => response["avsresponse"] }
         )
-        
+
       end
-      
+
       def expdate(creditcard)
         year  = sprintf("%.4i", creditcard.year)
         month = sprintf("%.2i", creditcard.month)
 
         "#{month}#{year[-2..-1]}"
       end
-      
 
+
       def message_from(response)
         case response["responsetext"]
         when "SUCCESS","Approved"
           "This transaction has been approved"
         when "DECLINE"
           "This transaction has been declined"
         else
           response["responsetext"]
         end
       end
-      
+
       def post_data(action, parameters = {})
         post = {}
         post[:username]      = @options[:login]
         post[:password]   = @options[:password]
         post[:type]       = action if action
 
         request = post.merge(parameters).map {|key,value| "#{key}=#{CGI.escape(value.to_s)}"}.join("&")
-        request        
+        request
       end
-      
+
       def determine_funding_source(source)
-        case 
+        case
         when source.is_a?(String) then :vault
         when CreditCard.card_companies.keys.include?(card_brand(source)) then :credit_card
         when card_brand(source) == 'check' then :check
         else raise ArgumentError, "Unsupported funding source provided"
         end