noctivityinc-activemerchant 1.5.1

data/README.rdoc

@@ -0,0 +1,136 @@
+= Active Merchant
+
+This library is supposed to aid in creating e-commerce software in Ruby.
+In the future we want to support all "good" payment gateways.
+
+This library is the foundation of commerce for http://www.shopify.com.
+
+Please visit the {ActiveMerchant homepage}[http://activemerchant.org] for more resources, tutorials and other information about this project.
+
+== Supported Direct Payment Gateways
+
+The {ActiveMerchant Wiki}[http://github.com/Shopify/active_merchant/wikis] contains a {table of features supported by each gateway}[http://github.com/Shopify/active_merchant/wikis/gatewayfeaturematrix].
+
+* {Authorize.Net CIM}[http://www.authorize.net/] - US
+* {Authorize.Net}[http://www.authorize.net/] - US
+* {Beanstream.com}[http://www.beanstream.com/] - CA
+* {Braintree}[http://www.braintreepaymentsolutions.com] - US
+* {CardStream}[http://www.cardstream.com/] - GB
+* {CyberSource}[http://www.cybersource.com] - US
+* {DataCash}[http://www.datacash.com/] - GB
+* {Efsnet}[http://www.concordefsnet.com/] - US
+* {eWAY}[http://www.eway.com.au/] - AU
+* {E-xact}[http://www.e-xact.com] - CA, US
+* {LinkPoint}[http://www.linkpoint.com/] - US
+* {Merchant e-Solutions}[http://merchante-solutions.com/] - US
+* {Modern Payments}[http://www.modpay.com] - US
+* {Moneris}[http://www.moneris.com/] - CA
+* {NetRegistry}[http://www.netregistry.com.au] - AU
+* {NELiX TransaX Gateway}[http://www.nelixtransax.com] - US
+* {NETbilling}[http://www.netbilling.com] - US
+* {PayJunction}[http://www.payjunction.com/] - US
+* {PaySecure}[http://www.commsecure.com.au/paysecure.shtml] - AU
+* {PayPal Express Checkout}[https://www.paypal.com/cgi-bin/webscr?cmd=xpt/merchant/ExpressCheckoutIntro-outside] - US, CA, SG, AU
+* {PayPal Payflow Pro}[https://www.paypal.com/cgi-bin/webscr?cmd=_payflow-pro-overview-outside] - US, CA, SG, AU
+* {PayPal Website Payments Pro (UK)}[https://www.paypal.com/uk/cgi-bin/webscr?cmd=_wp-pro-overview-outside] - GB
+* {PaymentExpress}[http://www.paymentexpress.com/] - AU, MY, NZ, SG, ZA, GB, US
+* {PayPal Website Payments Pro (CA)}[https://www.paypal.com/cgi-bin/webscr?cmd=_wp-pro-overview-outside] - CA
+* {PayPal Express Checkout}[https://www.paypal.com/cgi-bin/webscr?cmd=xpt/merchant/ExpressCheckoutIntro-outside] - US
+* {PayPal Website Payments Pro (US)}[https://www.paypal.com/cgi-bin/webscr?cmd=_wp-pro-overview-outside] - US
+* {Plug'n Pay}[http://www.plugnpay.com/] - US
+* {Protx}[http://www.protx.com] - GB
+* {Psigate}[http://www.psigate.com/] - CA
+* {PSL Payment Solutions}[http://www.paymentsolutionsltd.com/] - GB
+* {Quickpay}[http://quickpay.dk/] - DK
+* {Realex}[http://www.realexpayments.com/] - IE, GB
+* {Sage Payment Solutions}[http://www.sagepayments.com] - US, CA
+* {Sallie Mae}[http://www.salliemae.com] - US
+* {SecurePay}[http://securepay.com.au] - AU
+* {SecurePay}[http://www.securepay.com/] - US
+* {SecurePayTech}[http://www.securepaytech.com/] - NZ
+* {SkipJack}[http://www.skipjack.com/] - US, CA
+* {TransFirst}[http://www.transfirst.com/] - US
+* {TrustCommerce}[http://www.trustcommerce.com/] - US
+* {USA ePay}[http://www.usaepay.com/] - US
+* {Verifi}[http://www.verifi.com/] - US
+* {ViaKLIX}[http://viaklix.com] - US
+* {Wirecard}[http://www.wirecard.com] - DE
+
+== Supported Offsite Payment Gateways
+
+* {PayPal Website Payments Standard}[https://www.paypal.com/cgi-bin/webscr?cmd=_wp-standard-overview-outside]
+* Chronopay[http://www.chronopay.com]
+* Nochex[http://www.nochex.com]
+* {Banca Sella GestPay}[https://www.sella.it/banca/ecommerce/gestpay/gestpay.jsp]
+* {2 Checkout}[http://www.2checkout.com]
+* {HiTRUST}[http://www.hitrust.com.hk/]
+
+== Download
+
+Currently this library is available with git from:
+
+  git://github.com/Shopify/active_merchant.git
+
+== Installation
+
+=== From Git
+
+You can check out the latest source from git:
+
+  > git pull git://github.com/Shopify/active_merchant.git
+
+=== As a Rails plugin
+
+ActiveMerchant includes an init.rb file. This means that Rails will automatically load ActiveMerchant on startup. Run the following command from the root directory of your Rails project to install ActiveMerchant as a Rails plugin:
+
+  > ./script/plugin install git://github.com/Shopify/active_merchant.git
+
+=== From Ruby Gems
+
+Installation from RubyGems
+
+  > gem install activemerchant
+
+== Sample Usage
+  require 'rubygems'
+  require 'active_merchant'
+
+  # Use the TrustCommerce test servers
+  ActiveMerchant::Billing::Base.mode = :test
+
+  # ActiveMerchant accepts all amounts as Integer values in cents
+  # $10.00
+  amount = 1000
+
+  # The card verification value is also known as CVV2, CVC2, or CID 
+  credit_card = ActiveMerchant::Billing::CreditCard.new(
+                  :first_name         => 'Bob',
+                  :last_name          => 'Bobsen',
+                  :number             => '4242424242424242',
+                  :month              => '8',
+                  :year               => '2012',
+                  :verification_value => '123'
+                )
+
+  # Validating the card automatically detects the card type
+  if credit_card.valid?
+
+    # Create a gateway object for the TrustCommerce service
+    gateway = ActiveMerchant::Billing::TrustCommerceGateway.new(
+                :login => 'TestMerchant',
+                :password => 'password'
+              )
+
+    # Authorize for the amount
+    response = gateway.purchase(amount, credit_card)
+
+    if response.success?
+      puts "Successfully charged $#{sprintf("%.2f", amount / 100)} to the credit card #{credit_card.display_number}"
+    else
+      raise StandardError, response.message 
+    end
+  end
+
+== Contributing
+
+Please see the {ActiveMerchant Guide to Contributing}[http://github.com/Shopify/active_merchant/wikis/contributing] for information on adding a new gateway to ActiveMerchant.

data/gem-public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMRMwEQYDVQQDDApjb2R5
+ZmF1c2VyMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZFgNj
+b20wHhcNMDcwMjIyMTcyMTI3WhcNMDgwMjIyMTcyMTI3WjBBMRMwEQYDVQQDDApj
+b2R5ZmF1c2VyMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC6T4Iqt5iWvAlU
+iXI6L8UO0URQhIC65X/gJ9hL/x4lwSl/ckVm/R/bPrJGmifT+YooFv824N3y/TIX
+25o/lZtRj1TUZJK4OCb0aVzosQVxBHSe6rLmxO8cItNTMOM9wn3thaITFrTa1DOQ
+O3wqEjvW2L6VMozVfK1MfjL9IGgy0rCnl+2g4Gh4jDDpkLfnMG5CWI6cTCf3C1ye
+ytOpWgi0XpOEy8nQWcFmt/KCQ/kFfzBo4QxqJi54b80842EyvzWT9OB7Oew/CXZG
+F2yIHtiYxonz6N09vvSzq4CvEuisoUFLKZnktndxMEBKwJU3XeSHAbuS7ix40OKO
+WKuI54fHAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+BBR9QQpefI3oDCAxiqJW/3Gg6jI6qjANBgkqhkiG9w0BAQUFAAOCAQEAs0lX26O+
+HpyMp7WL+SgZuM8k76AjfOHuKajl2GEn3S8pWYGpsa0xu07HtehJhKLiavrfUYeE
+qlFtyYMUyOh6/1S2vfkH6VqjX7mWjoi7XKHW/99fkMS40B5SbN+ypAUst+6c5R84
+w390mjtLHpdDE6WQYhS6bFvBN53vK6jG3DLyCJc0K9uMQ7gdHWoxq7RnG92ncQpT
+ThpRA+fky5Xt2Q63YJDnJpkYAz79QIama1enSnd4jslKzSl89JS2luq/zioPe/Us
+hbyalWR1+HrhgPoSPq7nk+s2FQUBJ9UZFK1lgMzho/4fZgzJwbu+cO8SNuaLS/bj
+hPaSTyVU0yCSnw==
+-----END CERTIFICATE-----

data/lib/active_merchant/billing/avs_result.rb

@@ -0,0 +1,98 @@
+#!ruby19
+# encoding: utf-8
+
+module ActiveMerchant
+  module Billing 
+    # Implements the Address Verification System
+    # https://www.wellsfargo.com/downloads/pdf/biz/merchant/visa_avs.pdf
+    # http://en.wikipedia.org/wiki/Address_Verification_System
+    # http://apps.cybersource.com/library/documentation/dev_guides/CC_Svcs_IG/html/app_avs_cvn_codes.htm#app_AVS_CVN_codes_7891_48375
+    # http://imgserver.skipjack.com/imgServer/5293710/AVS%20and%20CVV2.pdf
+    # http://www.emsecommerce.net/avs_cvv2_response_codes.htm
+    class AVSResult
+      MESSAGES = {
+        'A' => 'Street address matches, but 5-digit and 9-digit postal code do not match.',
+        'B' => 'Street address matches, but postal code not verified.',
+        'C' => 'Street address and postal code do not match.',
+        'D' => 'Street address and postal code match.',
+        'E' => 'AVS data is invalid or AVS is not allowed for this card type.',
+        'F' => 'Card member\'s name does not match, but billing postal code matches.',
+        'G' => 'Non-U.S. issuing bank does not support AVS.',
+        'H' => 'Card member\'s name does not match. Street address and postal code match.',
+        'I' => 'Address not verified.',
+        'J' => 'Card member\'s name, billing address, and postal code match. Shipping information verified and chargeback protection guaranteed through the Fraud Protection Program.',
+        'K' => 'Card member\'s name matches but billing address and billing postal code do not match.',
+        'L' => 'Card member\'s name and billing postal code match, but billing address does not match.',
+        'M' => 'Street address and postal code match.',
+        'N' => 'Street address and postal code do not match.',
+        'O' => 'Card member\'s name and billing address match, but billing postal code does not match.',
+        'P' => 'Postal code matches, but street address not verified.',
+        'Q' => 'Card member\'s name, billing address, and postal code match. Shipping information verified but chargeback protection not guaranteed.',
+        'R' => 'System unavailable.',
+        'S' => 'U.S.-issuing bank does not support AVS.',
+        'T' => 'Card member\'s name does not match, but street address matches.',
+        'U' => 'Address information unavailable.',
+        'V' => 'Card member\'s name, billing address, and billing postal code match.',
+        'W' => 'Street address does not match, but 9-digit postal code matches.',
+        'X' => 'Street address and 9-digit postal code match.',
+        'Y' => 'Street address and 5-digit postal code match.',
+        'Z' => 'Street address does not match, but 5-digit postal code matches.'
+      }
+      
+      # Map vendor's AVS result code to a postal match code
+      POSTAL_MATCH_CODE = {
+        'Y' => %w( D H F H J L M P Q V W X Y Z ),
+        'N' => %w( A C K N O ),
+        'X' => %w( G S ),
+        nil => %w( B E I R T U )
+      }.inject({}) do |map, (type, codes)|
+        codes.each { |code| map[code] = type }
+        map
+      end
+      
+      # Map vendor's AVS result code to a street match code
+      STREET_MATCH_CODE = {
+        'Y' => %w( A B D H J M O Q T V X Y ),
+        'N' => %w( C K L N P W Z ),
+        'X' => %w( G S ),
+        nil => %w( E F I R U )
+      }.inject({}) do |map, (type, codes)|
+        codes.each { |code| map[code] = type }
+        map
+      end
+      
+      attr_reader :code, :message, :street_match, :postal_match
+      
+      def self.messages
+        MESSAGES
+      end
+      
+      def initialize(attrs)
+        attrs ||= {}
+        
+        @code = attrs[:code].upcase unless attrs[:code].blank?
+        @message = self.class.messages[code]
+        
+        if attrs[:street_match].blank?
+          @street_match = STREET_MATCH_CODE[code]
+        else  
+          @street_match = attrs[:street_match].upcase
+        end
+          
+        if attrs[:postal_match].blank?
+          @postal_match = POSTAL_MATCH_CODE[code]
+        else  
+          @postal_match = attrs[:postal_match].upcase
+        end
+      end
+    
+      def to_hash
+        { 'code' => code,
+          'message' => message,
+          'street_match' => street_match,
+          'postal_match' => postal_match
+        }
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/base.rb

@@ -0,0 +1,57 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Base
+      # Set ActiveMerchant gateways in test mode.
+      #
+      #   ActiveMerchant::Billing::Base.gateway_mode = :test
+      mattr_accessor :gateway_mode
+      
+      # Set ActiveMerchant integrations in test mode.
+      #
+      #   ActiveMerchant::Billing::Base.integration_mode = :test
+      mattr_accessor :integration_mode
+      
+      # Set both the mode of both the gateways and integrations
+      # at once
+      mattr_reader :mode
+
+      def self.mode=(mode)
+        @@mode = mode
+        self.gateway_mode = mode
+        self.integration_mode = mode
+      end
+
+      self.mode = :production
+                                                                
+      # Return the matching gateway for the provider
+      # * <tt>bogus</tt>: BogusGateway - Does nothing (for testing)
+      # * <tt>moneris</tt>: MonerisGateway
+      # * <tt>authorize_net</tt>: AuthorizeNetGateway
+      # * <tt>trust_commerce</tt>: TrustCommerceGateway
+      # 
+      #   ActiveMerchant::Billing::Base.gateway('moneris').new
+      def self.gateway(name)
+        Billing.const_get("#{name.to_s.downcase}_gateway".camelize)
+      end
+      
+
+      # Return the matching integration module
+      # You can then get the notification from the module
+      # * <tt>bogus</tt>: Bogus - Does nothing (for testing)      
+      # * <tt>chronopay</tt>: Chronopay - Does nothing (for testing)
+      # * <tt>paypal</tt>: Chronopay - Does nothing (for testing)
+      #   
+      #   chronopay = ActiveMerchant::Billing::Base.integration('chronopay')
+      #   notification = chronopay.notification(raw_post)
+      #
+      def self.integration(name)
+        Billing::Integrations.const_get("#{name.to_s.downcase}".camelize)
+      end
+      
+      # A check to see if we're in test mode
+      def self.test?
+        self.gateway_mode == :test
+      end
+    end             
+  end
+end

data/lib/active_merchant/billing/check.rb

@@ -0,0 +1,68 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # The Check object is a plain old Ruby object, similar to CreditCard. It supports validation
+    # of necessary attributes such as checkholder's name, routing and account numbers, but it is
+    # not backed by any database.
+    # 
+    # You may use Check in place of CreditCard with any gateway that supports it. Currently, only
+    # +BraintreeGateway+ supports the Check object.
+    class Check
+      include Validateable
+      
+      attr_accessor :first_name, :last_name, :routing_number, :account_number, :account_holder_type, :account_type, :number
+      
+      # Used for Canadian bank accounts
+      attr_accessor :institution_number, :transit_number
+      
+      def name
+        @name ||= "#{@first_name} #{@last_name}".strip
+      end
+      
+      def name=(value)
+        return if value.blank?
+
+        @name = value
+        segments = value.split(' ')
+        @last_name = segments.pop
+        @first_name = segments.join(' ')
+      end
+      
+      def validate
+        [:name, :routing_number, :account_number].each do |attr|
+          errors.add(attr, "cannot be empty") if self.send(attr).blank?
+        end
+        
+        errors.add(:routing_number, "is invalid") unless valid_routing_number?
+        
+        errors.add(:account_holder_type, "must be personal or business") if
+            !account_holder_type.blank? && !%w[business personal].include?(account_holder_type.to_s)
+        
+        errors.add(:account_type, "must be checking or savings") if
+            !account_type.blank? && !%w[checking savings].include?(account_type.to_s)
+      end
+      
+      def type
+        'check'
+      end
+      
+      # Routing numbers may be validated by calculating a checksum and dividing it by 10. The
+      # formula is:
+      #   (3(d1 + d4 + d7) + 7(d2 + d5 + d8) + 1(d3 + d6 + d9))mod 10 = 0
+      # See http://en.wikipedia.org/wiki/Routing_transit_number#Internal_checksums
+      def valid_routing_number?
+        d = routing_number.to_s.split('').map(&:to_i).select { |d| (0..9).include?(d) }
+        case d.size
+          when 9 then
+            checksum = ((3 * (d[0] + d[3] + d[6])) +
+                        (7 * (d[1] + d[4] + d[7])) +
+                             (d[2] + d[5] + d[8])) % 10
+            case checksum
+              when 0 then true
+              else        false
+            end
+          else false
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/credit_card.rb

@@ -0,0 +1,159 @@
+require 'time'
+require 'date'
+require 'active_merchant/billing/expiry_date'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # == Description
+    # This credit card object can be used as a stand alone object. It acts just like an ActiveRecord object
+    # but doesn't support the .save method as its not backed by a database.
+    # 
+    # For testing purposes, use the 'bogus' credit card type. This card skips the vast majority of 
+    # validations. This allows you to focus on your core concerns until you're ready to be more concerned 
+    # with the details of particular creditcards or your gateway.
+    # 
+    # == Testing With CreditCard
+    # Often when testing we don't care about the particulars of a given card type. When using the 'test' 
+    # mode in your Gateway, there are six different valid card numbers: 1, 2, 3, 'success', 'fail', 
+    # and 'error'.
+    # 
+    #--
+    # For details, see CreditCardMethods#valid_number?
+    #++
+    # 
+    # == Example Usage
+    #   cc = CreditCard.new(
+    #     :first_name => 'Steve', 
+    #     :last_name  => 'Smith', 
+    #     :month      => '9', 
+    #     :year       => '2010', 
+    #     :type       => 'visa', 
+    #     :number     => '4242424242424242'
+    #   )
+    #   
+    #   cc.valid? # => true
+    #   cc.display_number # => XXXX-XXXX-XXXX-4242
+    #
+    class CreditCard
+      include CreditCardMethods
+      include Validateable
+      
+      ## Attributes
+      
+      cattr_accessor :require_verification_value
+      self.require_verification_value = true
+      
+      # Essential attributes for a valid, non-bogus creditcards
+      attr_accessor :number, :month, :year, :type, :first_name, :last_name
+      
+      # Required for Switch / Solo cards
+      attr_accessor :start_month, :start_year, :issue_number
+
+      # Optional verification_value (CVV, CVV2 etc). Gateways will try their best to 
+      # run validation on the passed in value if it is supplied
+      attr_accessor :verification_value
+
+      # Provides proxy access to an expiry date object
+      def expiry_date
+        ExpiryDate.new(@month, @year)
+      end
+
+      def expired?
+        expiry_date.expired?
+      end
+      
+      def name?
+        first_name? && last_name?
+      end
+      
+      def first_name?
+        !@first_name.blank?
+      end
+      
+      def last_name?
+        !@last_name.blank?
+      end
+            
+      def name
+        "#{@first_name} #{@last_name}"
+      end
+            
+      def verification_value?
+        !@verification_value.blank?
+      end
+
+      # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
+      def display_number
+        self.class.mask(number)
+      end
+      
+      def last_digits
+        self.class.last_digits(number)
+      end
+      
+      def validate
+        validate_essential_attributes
+
+        # Bogus card is pretty much for testing purposes. Lets just skip these extra tests if its used
+        return if type == 'bogus'
+
+        validate_card_type
+        validate_card_number
+        validate_verification_value
+        validate_switch_or_solo_attributes
+      end
+      
+      def self.requires_verification_value?
+        require_verification_value
+      end
+      
+      private
+      
+      def before_validate #:nodoc: 
+        self.month = month.to_i
+        self.year  = year.to_i
+        self.start_month = start_month.to_i unless start_month.nil?
+        self.start_year = start_year.to_i unless start_year.nil?
+        self.number = number.to_s.gsub(/[^\d]/, "")
+        self.type.downcase! if type.respond_to?(:downcase)
+        self.type = self.class.type?(number) if type.blank?
+      end
+      
+      def validate_card_number #:nodoc:
+        errors.add :number, "is not a valid credit card number" unless CreditCard.valid_number?(number)
+        unless errors.on(:number) || errors.on(:type)
+          errors.add :type, "is not the correct card type" unless CreditCard.matching_type?(number, type)
+        end
+      end
+      
+      def validate_card_type #:nodoc:
+        errors.add :type, "is required" if type.blank?
+        errors.add :type, "is invalid"  unless CreditCard.card_companies.keys.include?(type)
+      end
+      
+      def validate_essential_attributes #:nodoc:
+        errors.add :first_name, "cannot be empty"      if @first_name.blank?
+        errors.add :last_name,  "cannot be empty"      if @last_name.blank?
+        errors.add :month,      "is not a valid month" unless valid_month?(@month)
+        errors.add :year,       "expired"              if expired?
+        errors.add :year,       "is not a valid year"  unless valid_expiry_year?(@year)
+      end
+      
+      def validate_switch_or_solo_attributes #:nodoc:
+        if %w[switch solo].include?(type)
+          unless valid_month?(@start_month) && valid_start_year?(@start_year) || valid_issue_number?(@issue_number)
+            errors.add :start_month,  "is invalid"      unless valid_month?(@start_month)
+            errors.add :start_year,   "is invalid"      unless valid_start_year?(@start_year)
+            errors.add :issue_number, "cannot be empty" unless valid_issue_number?(@issue_number)
+          end
+        end
+      end
+      
+      def validate_verification_value #:nodoc:
+        if CreditCard.requires_verification_value?
+          errors.add :verification_value, "is required" unless verification_value? 
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/credit_card_formatting.rb

@@ -0,0 +1,21 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module CreditCardFormatting
+      
+      # This method is used to format numerical information pertaining to credit cards. 
+      # 
+      #   format(2005, :two_digits)  # => "05"
+      #   format(05,   :four_digits) # => "0005"
+      def format(number, option)
+        return '' if number.blank?
+        
+        case option
+          when :two_digits  ; sprintf("%.2i", number)[-2..-1]
+          when :four_digits ; sprintf("%.4i", number)[-4..-1]
+          else number
+        end
+      end
+      
+    end
+  end
+end

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -0,0 +1,125 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Convenience methods that can be included into a custom Credit Card object, such as an ActiveRecord based Credit Card object.
+    module CreditCardMethods
+      CARD_COMPANIES = { 
+        'visa'               => /^4\d{12}(\d{3})?$/,
+        'master'             => /^(5[1-5]\d{4}|677189)\d{10}$/,
+        'discover'           => /^(6011|65\d{2})\d{12}$/,
+        'american_express'   => /^3[47]\d{13}$/,
+        'diners_club'        => /^3(0[0-5]|[68]\d)\d{11}$/,
+        'jcb'                => /^35(28|29|[3-8]\d)\d{12}$/,
+        'switch'             => /^6759\d{12}(\d{2,3})?$/,  
+        'solo'               => /^6767\d{12}(\d{2,3})?$/,
+        'dankort'            => /^5019\d{12}$/,
+        'maestro'            => /^(5[06-8]|6\d)\d{10,17}$/,
+        'forbrugsforeningen' => /^600722\d{10}$/,
+        'laser'              => /^(6304|6706|6771|6709)\d{8}(\d{4}|\d{6,7})?$/
+      }
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def valid_month?(month)
+        (1..12).include?(month)
+      end
+      
+      def valid_expiry_year?(year)
+        (Time.now.year..Time.now.year + 20).include?(year)
+      end
+      
+      def valid_start_year?(year)
+        year.to_s =~ /^\d{4}$/ && year.to_i > 1987
+      end
+      
+      def valid_issue_number?(number)
+        number.to_s =~ /^\d{1,2}$/
+      end
+      
+      module ClassMethods
+        # Returns true if it validates. Optionally, you can pass a card type as an argument and 
+        # make sure it is of the correct type.
+        #
+        # References:
+        # - http://perl.about.com/compute/perl/library/nosearch/P073000.htm
+        # - http://www.beachnet.com/~hstiles/cardtype.html
+        def valid_number?(number)
+          valid_test_mode_card_number?(number) || 
+            valid_card_number_length?(number) && 
+            valid_checksum?(number)
+        end
+        
+        # Regular expressions for the known card companies.
+        # 
+        # References: 
+        # - http://en.wikipedia.org/wiki/Credit_card_number 
+        # - http://www.barclaycardbusiness.co.uk/information_zone/processing/bin_rules.html 
+        def card_companies
+          CARD_COMPANIES
+        end
+        
+        # Returns a string containing the type of card from the list of known information below.
+        # Need to check the cards in a particular order, as there is some overlap of the allowable ranges
+        #--
+        # TODO Refactor this method. We basically need to tighten up the Maestro Regexp. 
+        # 
+        # Right now the Maestro regexp overlaps with the MasterCard regexp (IIRC). If we can tighten 
+        # things up, we can boil this whole thing down to something like... 
+        # 
+        #   def type?(number)
+        #     return 'visa' if valid_test_mode_card_number?(number)
+        #     card_companies.find([nil]) { |type, regexp| number =~ regexp }.first.dup
+        #   end
+        # 
+        def type?(number)
+          return 'bogus' if valid_test_mode_card_number?(number)
+
+          card_companies.reject { |c,p| c == 'maestro' }.each do |company, pattern|
+            return company.dup if number =~ pattern 
+          end
+          
+          return 'maestro' if number =~ card_companies['maestro']
+
+          return nil
+        end
+        
+        def last_digits(number)     
+          number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1) 
+        end
+        
+        def mask(number)
+          "XXXX-XXXX-XXXX-#{last_digits(number)}"
+        end
+        
+        # Checks to see if the calculated type matches the specified type
+        def matching_type?(number, type)
+          type?(number) == type
+        end
+        
+        private
+        
+        def valid_card_number_length?(number) #:nodoc:
+          number.to_s.length >= 12
+        end
+        
+        def valid_test_mode_card_number?(number) #:nodoc:
+          ActiveMerchant::Billing::Base.test? && 
+            %w[1 2 3 success failure error].include?(number.to_s)
+        end
+        
+        # Checks the validity of a card number by use of the the Luhn Algorithm. 
+        # Please see http://en.wikipedia.org/wiki/Luhn_algorithm for details.
+        def valid_checksum?(number) #:nodoc:
+          sum = 0
+          for i in 0..number.length
+            weight = number[-1 * (i + 2), 1].to_i * (2 - (i % 2))
+            sum += (weight < 10) ? weight : weight - 9
+          end
+          
+          (number[-1,1].to_i == (10 - sum % 10) % 10)
+        end
+      end
+    end
+  end
+end