activemerchant 1.43.3 → 1.44.0

data/lib/active_merchant/billing/compatibility.rb

@@ -0,0 +1,120 @@
+module ActiveMerchant
+  module Billing
+    module Compatibility
+      module Model
+        def valid?
+          Compatibility.deprecated
+          super
+        end
+
+        def errors
+          Compatibility.deprecated
+          internal_errors
+        end
+      end
+
+      @rails_required = false
+      def self.rails_required!
+        @rails_required = true
+      end
+
+      def self.deprecated
+        ActiveMerchant.deprecated(
+          %(Implicit inclusion of Rails-specific functionality is deprecated.) +
+          %( Explicitly require "active_merchant/billing/rails" if you need it.)
+        ) unless @rails_required
+      end
+
+      def self.humanize(lower_case_and_underscored_word)
+        result = lower_case_and_underscored_word.to_s.dup
+        result.gsub!(/_id$/, "")
+        result.gsub!(/_/, ' ')
+        result.gsub(/([a-z\d]*)/i) { |match|
+          match.downcase
+        }.gsub(/^\w/) { $&.upcase }
+      end
+    end
+  end
+end
+
+# This lives in compatibility until we remove the deprecation for implicitly
+# requiring Rails
+module ActiveMerchant
+  module Billing
+    module Rails
+      module Model
+        def valid?
+          internal_errors.clear
+
+          validate.each do |attribute, errors|
+            errors.each do |error|
+              internal_errors.add(attribute, error)
+            end
+          end
+
+          internal_errors.empty?
+        end
+
+        private
+
+        def internal_errors
+          @errors ||= Errors.new
+        end
+
+        class Errors < Hash
+          def initialize
+            super(){|h, k| h[k] = []}
+          end
+
+          alias count size
+
+          def [](key)
+            super(key.to_s)
+          end
+
+          def []=(key, value)
+            super(key.to_s, value)
+          end
+
+          def empty?
+            all?{|k, v| v && v.empty?}
+          end
+
+          def on(field)
+            self[field].to_a.first
+          end
+
+          def add(field, error)
+            self[field] << error
+          end
+
+          def add_to_base(error)
+            add(:base, error)
+          end
+
+          def each_full
+            full_messages.each{|msg| yield msg}
+          end
+
+          def full_messages
+            result = []
+
+            self.each do |key, messages|
+              next unless(messages && !messages.empty?)
+              if key == 'base'
+                result << "#{messages.first}"
+              else
+                result << "#{Compatibility.humanize(key)} #{messages.first}"
+              end
+            end
+
+            result
+          end
+        end
+      end
+    end
+
+    Compatibility::Model.send(:include, Rails::Model)
+  end
+end
+

data/lib/active_merchant/billing/credit_card.rb

@@ -1,6 +1,6 @@
 require 'time'
 require 'date'
-require 'active_merchant/billing/expiry_date'
+require "active_merchant/billing/model"
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
@@ -43,12 +43,11 @@ module ActiveMerchant #:nodoc:
     #     :number     => '4242424242424242'
     #   )
     #
-    #   cc.valid? # => true
+    #   cc.validate # => {}
     #   cc.display_number # => XXXX-XXXX-XXXX-4242
     #
-    class CreditCard
+    class CreditCard < Model
       include CreditCardMethods
-      include Validateable
 
       cattr_accessor :require_verification_value
       self.require_verification_value = true
@@ -56,17 +55,21 @@ module ActiveMerchant #:nodoc:
       # Returns or sets the credit card number.
       #
       # @return [String]
-      attr_accessor :number
+      attr_reader :number
+
+      def number=(value)
+        @number = (empty?(value) ? value : value.to_s.gsub(/[^\d]/, ""))
+      end
 
       # Returns or sets the expiry month for the card.
       #
       # @return [Integer]
-      attr_accessor :month
+      attr_reader :month
 
       # Returns or sets the expiry year for the card.
       #
       # @return [Integer]
-      attr_accessor :year
+      attr_reader :year
 
       # Returns or sets the credit card brand.
       #
@@ -88,7 +91,18 @@ module ActiveMerchant #:nodoc:
       # Or, if you wish to test your implementation, +'bogus'+.
       #
       # @return (String) the credit card brand
-      attr_accessor :brand
+      def brand
+        if !defined?(@brand) || empty?(@brand)
+          self.class.brand?(number)
+        else
+          @brand
+        end
+      end
+
+      def brand=(value)
+        value = value && value.to_s.dup
+        @brand = (value.respond_to?(:downcase) ? value.downcase : value)
+      end
 
       # Returns or sets the first name of the card holder.
       #
@@ -101,7 +115,8 @@ module ActiveMerchant #:nodoc:
       attr_accessor :last_name
 
       # Required for Switch / Solo cards
-      attr_accessor :start_month, :start_year, :issue_number
+      attr_reader :start_month, :start_year
+      attr_accessor :issue_number
 
       # Returns or sets the card verification value.
       #
@@ -118,12 +133,12 @@ module ActiveMerchant #:nodoc:
       attr_accessor :track_data
 
       def type
-        self.class.deprecated "CreditCard#type is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand instead."
+        ActiveMerchant.deprecated "CreditCard#type is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand instead."
         brand
       end
 
       def type=(value)
-        self.class.deprecated "CreditCard#type is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand instead."
+        ActiveMerchant.deprecated "CreditCard#type is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand instead."
         self.brand = value
       end
 
@@ -148,19 +163,19 @@ module ActiveMerchant #:nodoc:
 
       # Returns whether the +first_name+ attribute has been set.
       def first_name?
-        @first_name.present?
+        first_name.present?
       end
 
       # Returns whether the +last_name+ attribute has been set.
       def last_name?
-        @last_name.present?
+        last_name.present?
       end
 
       # Returns the full name of the card holder.
       #
       # @return [String] the full name of the card holder
       def name
-        [@first_name, @last_name].compact.join(' ')
+        [first_name, last_name].compact.join(' ')
       end
 
       def name=(full_name)
@@ -169,8 +184,21 @@ module ActiveMerchant #:nodoc:
         self.first_name = names.join(" ")
       end
 
+      %w(month year start_month start_year).each do |m|
+        class_eval %(
+          def #{m}=(v)
+            @#{m} = case v
+            when "", nil, 0
+              nil
+            else
+              v.to_i
+            end
+          end
+        )
+      end
+
       def verification_value?
-        !@verification_value.blank?
+        !verification_value.blank?
       end
 
       # Returns a display-friendly version of the card number.
@@ -199,15 +227,16 @@ module ActiveMerchant #:nodoc:
       #
       # Any validation errors are added to the {#errors} attribute.
       def validate
-        validate_essential_attributes
+        errors = validate_essential_attributes + validate_verification_value
 
         # Bogus card is pretty much for testing purposes. Lets just skip these extra tests if its used
-        return if brand == 'bogus'
+        return errors_hash(errors) if brand == 'bogus'
 
-        validate_card_brand
-        validate_card_number
-        validate_verification_value
-        validate_switch_or_solo_attributes
+        errors_hash(
+          errors +
+          validate_card_brand_and_number +
+          validate_switch_or_solo_attributes
+        )
       end
 
       def self.requires_verification_value?
@@ -216,66 +245,106 @@ module ActiveMerchant #:nodoc:
 
       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.brand.downcase! if brand.respond_to?(:downcase)
-        self.brand = self.class.brand?(number) if brand.blank?
+      def validate_essential_attributes #:nodoc:
+        errors = []
+
+        errors << [:first_name, "cannot be empty"] if first_name.blank?
+        errors << [:last_name,  "cannot be empty"] if last_name.blank?
+
+        if(empty?(month) || empty?(year))
+          errors << [:month, "is required"] if empty?(month)
+          errors << [:year,  "is required"] if empty?(year)
+        else
+          errors << [:month, "is not a valid month"] if !valid_month?(month)
+
+          if expired?
+            errors << [:year,  "expired"]
+          else
+            errors << [:year,  "is not a valid year"]  if !valid_expiry_year?(year)
+          end
+        end
+
+        errors
       end
 
-      def validate_card_number #:nodoc:
-        if number.blank?
-          errors.add :number, "is required"
+      def validate_card_brand_and_number #:nodoc:
+        errors = []
+
+        if !empty?(brand)
+          errors << [:brand, "is invalid"]  if !CreditCard.card_companies.keys.include?(brand)
+        end
+
+        if empty?(number)
+          errors << [:number, "is required"]
         elsif !CreditCard.valid_number?(number)
-          errors.add :number, "is not a valid credit card number"
+          errors << [:number, "is not a valid credit card number"]
         end
 
-        unless errors.on(:number) || errors.on(:brand)
-          errors.add :brand, "does not match the card number" unless CreditCard.matching_brand?(number, brand)
+        if errors.empty?
+          errors << [:brand, "does not match the card number"] if !CreditCard.matching_brand?(number, brand)
         end
-      end
 
-      def validate_card_brand #:nodoc:
-        errors.add :brand, "is required" if brand.blank? && number.present?
-        errors.add :brand, "is invalid"  unless brand.blank? || CreditCard.card_companies.keys.include?(brand)
+        errors
       end
 
-      alias_method :validate_card_type, :validate_card_brand
-
-      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?
+      def validate_verification_value #:nodoc:
+        errors = []
 
-        if @month.to_i.zero? || @year.to_i.zero?
-          errors.add :month, "is required"  if @month.to_i.zero?
-          errors.add :year,  "is required"  if @year.to_i.zero?
-        else
-          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 expired? || valid_expiry_year?(@year)
+        if verification_value?
+          unless valid_card_verification_value?(verification_value, brand)
+            errors << [:verification_value, "should be #{card_verification_value_length(brand)} digits"]
+          end
+        elsif CreditCard.requires_verification_value?
+          errors << [:verification_value, "is required"]
         end
+        errors
       end
 
       def validate_switch_or_solo_attributes #:nodoc:
+        errors = []
+
         if %w[switch solo].include?(brand)
-          unless valid_month?(@start_month) && valid_start_year?(@start_year) || valid_issue_number?(@issue_number)
-            if @issue_number.blank?
-              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"
+          valid_start_month = valid_month?(start_month)
+          valid_start_year = valid_start_year?(start_year)
+
+          if((!valid_start_month || !valid_start_year) && !valid_issue_number?(issue_number))
+            if empty?(issue_number)
+              errors << [:issue_number, "cannot be empty"]
+              errors << [:start_month, "is invalid"] if !valid_start_month
+              errors << [:start_year,  "is invalid"] if !valid_start_year
             else
-              errors.add :issue_number, "is invalid"      unless valid_issue_number?(@issue_number)
+              errors << [:issue_number, "is invalid"] if !valid_issue_number?(issue_number)
             end
           end
         end
+
+        errors
       end
 
-      def validate_verification_value #:nodoc:
-        if CreditCard.requires_verification_value?
-          errors.add :verification_value, "is required" unless verification_value?
+      class ExpiryDate #:nodoc:
+        attr_reader :month, :year
+        def initialize(month, year)
+          @month = month.to_i
+          @year = year.to_i
+        end
+
+        def expired? #:nodoc:
+          Time.now.utc > expiration
+        end
+
+        def expiration #:nodoc:
+          begin
+            Time.utc(year, month, month_days, 23, 59, 59)
+          rescue ArgumentError
+            Time.at(0).utc
+          end
+        end
+
+        private
+        def month_days
+          mdays = [nil,31,28,31,30,31,30,31,31,30,31,30,31]
+          mdays[2] = 29 if Date.leap?(year)
+          mdays[month]
         end
       end
     end

data/lib/active_merchant/billing/credit_card_formatting.rb

@@ -2,6 +2,10 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module CreditCardFormatting
 
+      def expdate(credit_card)
+        "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
+      end
+
       # This method is used to format numerical information pertaining to credit cards.
       #
       #   format(2005, :two_digits)  # => "05"
@@ -15,7 +19,6 @@ module ActiveMerchant #:nodoc:
           else number
         end
       end
-
     end
   end
 end

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -2,7 +2,7 @@ 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 = { 
+      CARD_COMPANIES = {
         'visa'               => /^4\d{12}(\d{3})?$/,
         'master'             => /^(5[1-5]\d{4}|677189)\d{10}$/,
         'discover'           => /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/,
@@ -16,116 +16,133 @@ module ActiveMerchant #:nodoc:
         'forbrugsforeningen' => /^600722\d{10}$/,
         'laser'              => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
       }
-    
+
       def self.included(base)
         base.extend(ClassMethods)
       end
-      
+
       def valid_month?(month)
         (1..12).include?(month.to_i)
       end
-      
+
       def valid_expiry_year?(year)
         (Time.now.year..Time.now.year + 20).include?(year.to_i)
       end
-      
+
       def valid_start_year?(year)
-        year.to_s =~ /^\d{4}$/ && year.to_i > 1987
+        ((year.to_s =~ /^\d{4}$/) && (year.to_i > 1987))
+      end
+
+      # Credit card providers have 3 digit verification values
+      # This isn't standardised, these are called various names such as
+      # CVC, CVV, CID, CSC and more
+      # See: http://en.wikipedia.org/wiki/Card_security_code
+      # American Express is the exception with 4 digits
+      #
+      # Below are links from the card providers with their requirements
+      # visa:             http://usa.visa.com/personal/security/3-digit-security-code.jsp
+      # master:           http://www.mastercard.com/ca/merchant/en/getstarted/Anatomy_MasterCard.html
+      # jcb:              http://www.jcbcard.com/security/info.html
+      # diners_club:      http://www.dinersclub.com/assets/DinersClub_card_ID_features.pdf
+      # discover:         https://www.discover.com/credit-cards/help-center/glossary.html
+      # american_express: https://online.americanexpress.com/myca/fuidfyp/us/action?request_type=un_fuid&Face=en_US
+      def valid_card_verification_value?(cvv, brand)
+        cvv.to_s =~ /^\d{#{card_verification_value_length(brand)}}$/
       end
       
-      def valid_issue_number?(number)
-        number.to_s =~ /^\d{1,2}$/
+      def card_verification_value_length(brand)
+        brand == 'american_express' ? 4 : 3
       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 brand as an argument and 
+        # Returns true if it validates. Optionally, you can pass a card brand as an argument and
         # make sure it is of the correct brand.
         #
         # 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_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 
+        #
+        # 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 brand 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... 
-        # 
+        # 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 brand?(number)
         #     return 'visa' if valid_test_mode_card_number?(number)
         #     card_companies.find([nil]) { |brand, regexp| number =~ regexp }.first.dup
         #   end
-        # 
+        #
         def brand?(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 
+            return company.dup if number =~ pattern
           end
-          
+
           return 'maestro' if number =~ card_companies['maestro']
 
           return nil
         end
 
         def type?(number)
-          deprecated "CreditCard#type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand? instead."
+          ActiveMerchant.deprecated "CreditCard#type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand? instead."
           brand?(number)
         end
-        
+
         def first_digits(number)
-          number.to_s.slice(0,6) 
+          number.to_s.slice(0,6)
         end
-        
-        def last_digits(number)     
-          number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1) 
+
+        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 brand matches the specified brand
         def matching_brand?(number, brand)
           brand?(number) == brand
         end
 
         def matching_type?(number, brand)
-          deprecated "CreditCard#matching_type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#matching_brand? instead."
+          ActiveMerchant.deprecated "CreditCard#matching_type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#matching_brand? instead."
           matching_brand?(number, brand)
         end
 
-        def deprecated(message)
-          warn(Kernel.caller[1] + message)
-        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? && 
+          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 Luhn Algorithm.
         # Please see http://en.wikipedia.org/wiki/Luhn_algorithm for details.
         def valid_checksum?(number) #:nodoc:
@@ -134,7 +151,7 @@ module ActiveMerchant #:nodoc:
             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