cardia 0.0.1

data/lib/credit_card.rb

@@ -0,0 +1,189 @@
+require 'time'
+require 'validateable'
+
+module ActiveMerchant
+  module Billing
+    
+    # Represents a credit card
+    class CreditCard
+      include Validateable
+
+      attr_accessor :number, :month, :year, :first_name, :last_name, :type
+      
+      # Creates a new Credit card instance
+      # Valid options are
+      # * :number
+      # * :month
+      # * :year
+      # * :first_name
+      # * :last_name
+      # * :verification_value
+      # * :type
+      def initialize(options = {})
+        options.each do |key, value|
+          self.send("#{key}=", value)
+        end
+      end
+
+      # Optional verification_value (CVV, CVV2 etc)
+      attr_accessor :verification_value
+
+      def to_param #:nodoc:
+        return {
+          :number => self.number,
+          :month => self.month,
+          :year => self.year,
+          :type => self.type,
+          :first_name => self.first_name,
+          :last_name => self.last_name,
+          :verification_value => self.verification_value}
+      end
+      
+      # Returns a valid credit card (visa) for testing purposes. 
+      def self.valid_card_for_testing
+        result = self.new
+        result.number               = "4569971388844836"
+        result.verification_value   = "081"
+        result.expiry_date          = Date.parse("2017-03-01")
+        result.type                 = "visa"
+        result.first_name           = "John"
+        result.last_name            = "Doe"
+        return result
+      end
+      
+      # Returns an invalid credit card for testing purposes
+      def self.invalid_card_for_testing
+        result = self.valid_card_for_testing
+        result.number = "45699713888448360"
+        return result
+      end
+
+      def before_validate #:nodoc:
+        self.type.downcase! if type.respond_to?(:downcase)
+        self.month = month.to_i
+        self.year = year.to_i
+        self.number.to_s.gsub!(/[^\d]/, "")
+      end
+
+      def validate #:nodoc:
+        @errors.add "year", "expired"                             if expired?
+        #@errors.add "first_name", "cannot be empty"               unless @first_name
+        #@errors.add "last_name", "cannot be empty"                unless @last_name
+        @errors.add "month", "cannot be empty"                    unless (1..12).include?(month.to_i)
+        @errors.add "year", "cannot be empty"                     unless (Time.now.year..Time.now.year+10).include?(year.to_i)
+
+        # Bogus card is pretty much for testing purposes. Lets just skip these extra tests if its used
+        return if type == 'bogus'
+
+        @errors.add "number", "is not a vaild credit card number" unless CreditCard.valid_number?(number)
+        @errors.add "type", "is invalid."                         unless CreditCard.card_companies.include?(type)
+        @errors.add "type", "is not the correct card type"        unless CreditCard.type?(number) == type
+      end
+
+      # Expiry date in mmyy format
+      def expires
+        expiry_date.strftime("%m%y")
+      end
+      
+      # Sets the expiry date, takes a Date instance
+      def expiry_date=(a_date)
+        self.year = a_date.year
+        self.month = a_date.month
+      end
+
+      def expiry_date #:nodoc:
+        Date.parse("#{year}-#{month}-01")
+      end
+
+      def expired? #:nodoc:
+        Time.now > Time.parse("#{month}/28/#{year}") rescue true
+      end
+
+      def name? #:nodoc:
+        @first_name != nil and @last_name != nil
+      end
+
+      def first_name? #:nodoc:
+        @first_name != nil
+      end
+
+      def last_name? #:nodoc:
+        @last_name != nil
+      end
+
+      def name #:nodoc:
+        "#{@first_name} #{@last_name}"
+      end
+
+      def payment_type
+        "1000"
+      end
+
+      def verification_value? #:nodoc:
+        @verification_value != nil
+      end
+
+      # Get the regexps for different card companies
+      # == Known card types
+      # *Card Type*                       *Prefix*                         *Length*
+      # mastercard                        51-55                            16
+      # visa                              4                                13, 16
+      # american_express                  34, 37                           15
+      # diners_club                       300-305, 36, 38                  14
+      # enroute                           2014, 2149                       15
+      # discover                          6011                             16
+      # jcb                               3                                16
+      # jcb                               2131, 1800                       15
+      # bankcard                          5610, 56022[1-5]                 16
+      # switch                            various                          16,18,19
+      # solo                              63, 6767                         16,18,19
+      def self.card_companies_to_pattern #:nodoc:
+        {
+          'visa' =>  /^4\d{12}(\d{3})?$/,
+          'master' =>  /^5[1-5]\d{14}$/,
+          'discover' =>  /^6011\d{12}$/,
+          'american_express' =>  /^3[47]\d{13}$/,
+          'diners_club' =>  /^3(0[0-5]|[68]\d)\d{11}$/,
+          'enroute' =>  /^2(014|149)\d{11}$/,
+          'jcb' =>  /^(3\d{4}|2131|1800)\d{11}$/,
+          'bankcard' =>  /^56(10\d\d|022[1-5])\d{10}$/,
+          'switch' =>  [/^49(03(0[2-9]|3[5-9])|11(0[1-2]|7[4-9]|8[1-2])|36[0-9]{2})\d{10}(\d{2,3})?$/, /^564182\d{10}(\d{2,3})?$/, /^6(3(33[0-4][0-9])|759[0-9]{2})\d{10}(\d{2,3})?$/],
+          'solo' =>  /^6(3(34[5-9][0-9])|767[0-9]{2})\d{10}(\d{2,3})?$/
+        }
+      end
+
+      def self.card_companies #:nodoc:
+        return card_companies_to_pattern.keys
+      end
+
+      # Returns a string containing the type of card from the list of known information below.
+      def self.type?(number) #:nodoc:
+        card_companies_to_pattern.each do |company, patterns|
+          return company if [patterns].flatten.any? { |pattern| number =~ pattern  }
+        end
+      end
+
+      # 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 self.valid_number?(number)
+        return false unless number.to_s.length >= 13
+
+        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
+
+      # Show the card number, with all but last 4 numbers replace with "x". (xxxxxxxxxxxx-4338)
+      def display_number
+        return @number if @number.blank? || @number.length < 5
+        "#{'x' * (@number.length - 4)}-#{@number[-4, 4]}"
+      end
+    end
+  end
+end

data/lib/enum.rb

@@ -0,0 +1,78 @@
+# Provides simple enumerability to classes
+class Object #:nodoc:
+
+   # The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval(&blk); metaclass.instance_eval &blk; end
+
+   # Adds methods to a metaclass
+   def meta_def name, &blk
+     meta_eval { define_method name, &blk }
+   end
+
+   # Defines an instance method within a class
+   def class_def name, &blk
+     class_eval { define_method name, &blk }
+   end
+ end
+
+class Enum #:nodoc:
+  attr_reader :code
+
+  def initialize(a_code)
+    @code = a_code.to_i unless a_code.nil?
+  end
+
+  def ==(an_object)
+    self.class == an_object.class and self.code == an_object.code
+  end
+
+  def self.enums
+    @enums ||= {}
+  end
+
+  # Adds a new enum code.
+  # If description isn't provided, name is used instead
+  def self.map(name, a_code, description=nil)
+    enum_description = (description || name.to_s)
+    self.enums[a_code] = enum_description
+    self.define_constructor(name, a_code)
+    define_method "#{name}?" do
+      return @code == a_code
+    end
+  end
+
+  def self.define_constructor(name, a_code)
+    meta_def(name.to_sym) do
+      return self.new(a_code)
+    end
+  end
+
+  def to_s
+    description
+  end
+
+  def description
+    self.class.enums[@code]
+  end
+end
+
+
+module Enumerable #:nodoc:
+  class Mapper #:nodoc:
+    def initialize( collection )
+      @collection = collection
+    end
+    def method_missing( meth_id, *args)
+      @collection.map{ |a| a.send(meth_id, *args) }
+    end
+  end
+
+  def mapped
+    Mapper.new( self )
+  end
+
+  alias :collected :mapped
+
+end
+

data/lib/validateable.rb

@@ -0,0 +1,80 @@
+module ActiveMerchant #:nodoc:
+  
+  # Implements the standard ActiveRecord stuff for non-AR classes
+  module Validateable #:nodoc:
+    def valid?
+      errors.clear
+
+      before_validate if respond_to?(:before_validate)
+      validate if respond_to?(:validate)
+
+      errors.empty?
+    end  
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+    end
+
+    def errors    
+      @errors ||= Error.new(self)
+    end
+
+    private
+
+    def attributes=(attributes)
+      unless attributes.nil?
+        for key, value in attributes
+          send("#{key}=", value )            
+        end
+      end
+    end  
+
+    # This hash keeps the errors of the object
+    class Error < Hash #:nodoc:
+
+      def initialize(base)
+        @base = base
+      end
+      
+      def count
+        size
+      end
+
+      # returns a specific fields error message. 
+      # if more than one error is available we will only return the first. If no error is available 
+      # we return an empty string
+      def on(field)
+        self[field].to_a.first
+      end
+
+      def add(field, error)
+        self[field] ||= []
+        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| 
+          if key == :base
+            result << "#{messages.first}"
+          else
+            result << "#{key.to_s.humanize} #{messages.first}"
+          end
+        end
+
+        result
+      end   
+    end  
+  end
+  
+  
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme]
+RubiGen::Scripts::Generate.new.run(ARGV)