merb_merchant 1.4.1

data/lib/core_ext/delegating_attributes.rb

@@ -0,0 +1,76 @@
+#--
+# Copyright (c) 2005 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# These class attributes behave something like the class
+# inheritable accessors.  But instead of copying the hash over at
+# the time the subclass is first defined,  the accessors simply
+# delegate to their superclass unless they have been given a 
+# specific value.  This stops the strange situation where values 
+# set after class definition don't get applied to subclasses.
+class Class
+  unless respond_to? :superclass_delegating_reader
+    def superclass_delegating_reader(*names)
+      class_name_to_stop_searching_on = self.superclass.name.blank? ? "Object" : self.superclass.name
+      names.each do |name|
+        class_eval <<-EOS
+        def self.#{name}                                            # def self.only_reader
+          if defined?(@#{name})                                     #   if defined?(@only_reader)
+            @#{name}                                                #     @only_reader
+          elsif superclass < #{class_name_to_stop_searching_on} &&  #   elsif superclass < Object &&
+                superclass.respond_to?(:#{name})                    #         superclass.respond_to?(:only_reader)
+            superclass.#{name}                                      #     superclass.only_reader
+          end                                                       #   end
+        end                                                         # end
+        def #{name}                                                 # def only_reader
+          self.class.#{name}                                        #   self.class.only_reader
+        end                                                         # end
+        def self.#{name}?                                           # def self.only_reader?
+          !!#{name}                                                 #   !!only_reader
+        end                                                         # end
+        def #{name}?                                                # def only_reader?
+          !!#{name}                                                 #   !!only_reader
+        end                                                         # end
+        EOS
+      end
+    end
+  end
+  
+  unless respond_to? :superclass_delegating_writer
+    def superclass_delegating_writer(*names)
+      names.each do |name|
+        class_eval <<-EOS
+          def self.#{name}=(value)  # def self.only_writer=(value)
+            @#{name} = value        #   @only_writer = value
+          end                       # end
+        EOS
+      end
+    end
+  end
+  
+  unless respond_to? :superclass_delegating_accessor
+    def superclass_delegating_accessor(*names)
+      superclass_delegating_reader(*names)
+      superclass_delegating_writer(*names)
+    end
+  end
+end

data/lib/core_ext/hash_ext.rb

@@ -0,0 +1,35 @@
+class Hash
+  
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols.
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to symbols.
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  alias_method :to_options!, :symbolize_keys!
+
+end

data/lib/core_ext/inheritable_attributes.rb

@@ -0,0 +1,145 @@
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
+        def self.#{sym}                        # def self.before_add_for_comments
+          read_inheritable_attribute(:#{sym})  #   read_inheritable_attribute(:before_add_for_comments)
+        end                                    # end
+                                               #
+        def #{sym}                             # def before_add_for_comments
+          self.class.#{sym}                    #   self.class.before_add_for_comments
+        end                                    # end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    options = syms.last.is_a?(::Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)                          # def self.color=(obj)
+          write_inheritable_attribute(:#{sym}, obj)    #   write_inheritable_attribute(:color, obj)
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def color=(obj)
+          self.class.#{sym} = obj                      #   self.class.color = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    options = syms.last.is_a?(::Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)                          # def self.levels=(obj)
+          write_inheritable_array(:#{sym}, obj)        #   write_inheritable_array(:levels, obj)
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def levels=(obj)
+          self.class.#{sym} = obj                      #   self.class.levels = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    options = syms.last.is_a?(::Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)                          # def self.nicknames=(obj)
+          write_inheritable_hash(:#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def nicknames=(obj)
+          self.class.#{sym} = obj                      #   self.class.nicknames = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => is_duplicable?(value) ? value.dup : value)
+        end
+      end
+
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+    
+    def is_duplicable?(val)
+      case val.class
+      when NilClass, FalseClass, TrueClass, Symbol, Numeric, Class
+        false
+      else
+        true
+      end
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/core_ext/time_dsl.rb

@@ -0,0 +1,59 @@
+# Provides a a simple way of calling time units and to see the elapsed time between 2 moments
+# ==== Examples
+#   142.minutes => returns a value in seconds
+#   7.days => returns a value in seconds
+#   1.week => returns a value in seconds
+#   2.weeks.ago => returns a date
+#   1.year.since(time) => returns a date
+#   5.months.since(2.weeks.from_now) => returns a date
+module TimeDSL
+  
+  def second
+    self * 1
+  end
+  alias_method :seconds, :second
+  
+  def minute
+    self * 60
+  end
+  alias_method :minutes, :minute
+  
+  def hour
+    self * 3600
+  end
+  alias_method :hours, :hour
+  
+  def day
+    self * 86400
+  end
+  alias_method :days, :day
+  
+  def week
+    self * 604800
+  end
+  alias_method :weeks, :week
+  
+  def month
+    self * 2592000
+  end
+  alias_method :months, :month
+  
+  def year
+    self * 31471200
+  end
+  alias_method :years, :year
+  
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.now)
+    time - self
+  end
+  alias :until :ago
+  
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.now)
+    time + self
+  end
+  alias :from_now :since
+end
+
+Numeric.send :include, TimeDSL

data/lib/merb_merchant.rb

@@ -0,0 +1,96 @@
+#--
+# Copyright (c) 2005-2007 Tobias Luetke
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+                    
+$:.unshift(File.dirname(__FILE__))      
+
+# Include rails' active support for all the core extensions we love
+# begin
+#   require 'active_support'
+# rescue LoadError
+#   require 'rubygems'
+#   
+#   if respond_to? :gem
+#     gem 'activesupport', ">=2.0.0"
+#     require 'active_support'
+#   else
+#     require_gem 'activesupport'
+#   end
+# end
+
+# Include extlib for a better memory footprint
+begin
+  require 'extlib'
+rescue LoadError
+  require 'rubygems'
+  
+  if respond_to? :gem
+    gem 'extlib', ">= 0.9.10"
+    require 'extlib'
+  else
+    require_gem 'extlib'
+  end
+end
+
+require 'core_ext/delegating_attributes'
+require 'core_ext/inheritable_attributes'
+require 'core_ext/hash_ext'
+require 'core_ext/time_dsl'
+
+begin
+  require 'builder'
+rescue LoadError
+  require 'rubygems'
+  require 'builder'
+end
+
+require 'cgi'
+
+require 'merb_merchant/lib/utils'
+require 'merb_merchant/lib/error'
+require 'merb_merchant/lib/inflector'
+require 'merb_merchant/lib/validateable'
+require 'merb_merchant/lib/posts_data'
+require 'merb_merchant/lib/post_data'
+require 'merb_merchant/lib/requires_parameters'
+
+# Require the country class
+require 'merb_merchant/lib/country'
+
+# Address Verification
+require 'merb_merchant/billing/avs_result'
+
+# Card Verfication Code
+require 'merb_merchant/billing/cvv_result'
+
+# CreditCard Utility class. 
+require 'merb_merchant/billing/credit_card_methods'
+require 'merb_merchant/billing/credit_card_formatting'
+require 'merb_merchant/billing/credit_card'
+
+require 'merb_merchant/billing/base'
+
+# Require the supported gateways
+require 'merb_merchant/billing/gateways'
+
+# Require the supported integrations
+require 'merb_merchant/billing/integrations'

data/lib/merb_merchant/billing/avs_result.rb

@@ -0,0 +1,95 @@
+module MerbMerchant
+  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