am_credit_card 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# See: am_credit_card.gemspec
+gemspec

data/README.md

@@ -0,0 +1,50 @@
+am_credit_card
+==============
+
+[ActiveMerchant::Billing::CreditCard][1], without [ActiveMerchant][2].
+
+[1]: https://github.com/Shopify/active_merchant/blob/master/lib/active_merchant/billing/credit_card.rb
+[2]: http://activemerchant.rubyforge.org/
+
+
+Why?
+----
+
+ActiveMerchant has [nice credit card validations][1], but also lots of [dependencies][2] and other code. That's fine for those using the rest of ActiveMerchant, but if you're just after it's credit card model/validations, this is for you.
+
+[1]: https://github.com/Shopify/active_merchant/blob/master/lib/active_merchant/billing/credit_card_methods.rb
+[2]: https://github.com/Shopify/active_merchant/blob/master/activemerchant.gemspec#L21
+
+
+Usage
+-----
+
+    ```ruby
+    # Gemfile
+    gem "am_credit_card"
+    ```
+
+    ```ruby
+    # Instantiation
+    card = ActiveMerchant::Billing::CreditCard.new(
+      :first_name         => "Bob",
+      :last_name          => "Bobsen",
+      :number             => "4242424242424242",
+      :month              => "8",
+      :year               => "2012",
+      :verification_value => "123"
+    )
+
+    # Validation
+    card.valid?
+    card.errors
+    ```
+
+
+License
+-------
+
+ActiveMerchant is Copyright © 2005-2010 Tobias Luetke.
+He has released it open-source under the [MIT license][1]
+
+[1]: https://github.com/Shopify/active_merchant/blob/master/MIT-LICENSE

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake'
+require 'rake/testtask'
+
+desc "Run the unit test suite"
+task :default => 'test:units'
+
+namespace :test do
+
+  Rake::TestTask.new(:units) do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.ruby_opts << '-rubygems'
+    t.libs << 'test'
+    t.verbose = true
+  end
+
+end

data/am_credit_card.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/am_credit_card_version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Paul Annesley"]
+  gem.email         = ["paul@annesley.cc"]
+  gem.description   = %q{ActiveMerchant::Billing::CreditCard, without ActiveMerchant}
+  gem.summary       = %q{ActiveMerchant has nice credit card validations, but also lots of dependencies and other code. That's fine for those using the rest of ActiveMerchant, but if you're just after it's credit card model/validations, this is for you.
+}
+  gem.homepage      = "https://github.com/pda/am_credit_card"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "am_credit_card"
+  gem.require_paths = ["lib"]
+  gem.version       = AmCreditCard::VERSION
+
+  gem.add_dependency('activesupport', '>= 2.3.11')
+  gem.add_dependency('i18n')
+end

data/lib/active_merchant/billing/base.rb

@@ -0,0 +1,27 @@
+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 both the mode of both the gateways and integrations
+      # at once
+      mattr_reader :mode
+
+      def self.mode=(mode)
+        @@mode = mode
+        self.gateway_mode = mode
+      end
+
+      self.mode = :production
+                                                                
+      # 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/credit_card.rb

@@ -0,0 +1,260 @@
+require 'time'
+require 'date'
+require 'active_merchant/billing/expiry_date'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # A +CreditCard+ object represents a physical credit card, and is capable of validating the various
+    # data associated with these.
+    #
+    # At the moment, the following credit card types are supported:
+    #
+    # * Visa
+    # * MasterCard
+    # * Discover
+    # * American Express
+    # * Diner's Club
+    # * JCB
+    # * Switch
+    # * Solo
+    # * Dankort
+    # * Maestro
+    # * Forbrugsforeningen
+    # * Laser
+    #
+    # For testing purposes, use the 'bogus' credit card type. This skips the vast majority of
+    # validations, allowing you to focus on your core concerns until you're ready to be more concerned
+    # with the details of particular credit cards 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::ClassMethods#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
+
+      cattr_accessor :require_verification_value
+      self.require_verification_value = true
+
+      # Returns or sets the credit card number.
+      #
+      # @return [String]
+      attr_accessor :number
+
+      # Returns or sets the expiry month for the card.
+      #
+      # @return [Integer]
+      attr_accessor :month
+
+      # Returns or sets the expiry year for the card.
+      #
+      # @return [Integer]
+      attr_accessor :year
+
+      # Returns or sets the credit card type.
+      #
+      # Valid card types are
+      #
+      # * +'visa'+
+      # * +'master'+
+      # * +'discover'+
+      # * +'american_express'+
+      # * +'diners_club'+
+      # * +'jcb'+
+      # * +'switch'+
+      # * +'solo'+
+      # * +'dankort'+
+      # * +'maestro'+
+      # * +'forbrugsforeningen'+
+      # * +'laser'+
+      #
+      # Or, if you wish to test your implementation, +'bogus'+.
+      #
+      # @return (String) the credit card type
+      attr_accessor :type
+
+      # Returns or sets the first name of the card holder.
+      #
+      # @return [String]
+      attr_accessor :first_name
+
+      # Returns or sets the last name of the card holder.
+      #
+      # @return [String]
+      attr_accessor :last_name
+
+      # Required for Switch / Solo cards
+      attr_accessor :start_month, :start_year, :issue_number
+
+      # Returns or sets the card verification value.
+      #
+      # This attribute is optional but recommended. The verification value is
+      # a {card security code}[http://en.wikipedia.org/wiki/Card_security_code]. If provided,
+      # the gateway will attempt to validate the value.
+      #
+      # @return [String] the verification value
+      attr_accessor :verification_value
+
+      alias_method :brand, :type
+
+      # Provides proxy access to an expiry date object
+      #
+      # @return [ExpiryDate]
+      def expiry_date
+        ExpiryDate.new(@month, @year)
+      end
+
+      # Returns whether the credit card has expired.
+      #
+      # @return +true+ if the card has expired, +false+ otherwise
+      def expired?
+        expiry_date.expired?
+      end
+
+      # Returns whether either the +first_name+ or the +last_name+ attributes has been set.
+      def name?
+        first_name? || last_name?
+      end
+
+      # Returns whether the +first_name+ attribute has been set.
+      def first_name?
+        @first_name.present?
+      end
+
+      # Returns whether the +last_name+ attribute has been set.
+      def last_name?
+        @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(' ')
+      end
+
+      def name=(full_name)
+        names = full_name.split
+        self.last_name  = names.pop
+        self.first_name = names.join(" ")
+      end
+
+      def verification_value?
+        !@verification_value.blank?
+      end
+
+      # Returns a display-friendly version of the card number.
+      #
+      # All but the last 4 numbers are replaced with an "X", and hyphens are
+      # inserted in order to improve legibility.
+      #
+      # @example
+      #   credit_card = CreditCard.new(:number => "2132542376824338")
+      #   credit_card.display_number  # "XXXX-XXXX-XXXX-4338"
+      #
+      # @return [String] a display-friendly version of the card number
+      def display_number
+        self.class.mask(number)
+      end
+
+      def last_digits
+        self.class.last_digits(number)
+      end
+
+      # Validates the credit card details.
+      #
+      # Any validation errors are added to the {#errors} attribute.
+      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:
+        if number.blank?
+          errors.add :number, "is required"
+        elsif !CreditCard.valid_number?(number)
+          errors.add :number, "is not a valid credit card number"
+        end
+
+        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? && number.present?
+        errors.add :type, "is invalid"  unless type.blank? || 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?
+
+        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)
+        end
+      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_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}|64[4-9]\d)\d{12}|(62\d{14})$/,
+        '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.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
+      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