merchant_sidekick 0.4.2

data/lib/merchant_sidekick/addressable/address.rb

@@ -0,0 +1,400 @@
+module MerchantSidekick
+  module Addressable
+    # Super class of all types of addresses
+    class Address < ActiveRecord::Base
+      self.table_name = "addresses"
+
+      #--- column mapping
+      cattr_accessor :street_address_column
+      @@street_address_column = :street
+
+      cattr_accessor :city_column
+      @@city_column = :city
+
+      cattr_accessor :postal_code_column
+      @@postal_code_column = :postal_code
+
+      cattr_accessor :province_column
+      @@province_column = :province
+
+      cattr_accessor :province_code_column
+      @@province_code_column = :province_code
+
+      cattr_accessor :country_column
+      @@country_column = :country
+
+      cattr_accessor :country_code_column
+      @@country_code_column = :country_code
+
+      cattr_accessor :gender_column
+      @@gender_column = :gender
+
+      cattr_accessor :first_name_column
+      @@first_name_column = :first_name
+
+      cattr_accessor :middle_name_column
+      @@middle_name_column = false
+
+      cattr_accessor :last_name_column
+      @@last_name_column = :last_name
+
+      #--- associations
+      belongs_to :addressable, :polymorphic => true
+
+      #--- validations
+      # extend your Address class with validation as you please
+
+      #--- callbacks
+
+      # This particular call back could be used to save
+      # geocordinates if addressable defines :before_save_address method
+      def before_save
+        # trigger before_save_address
+        self.addressable.send(:before_save_address, self) if addressable && addressable.respond_to?(:before_save_address)
+      end
+
+      #--- class methods
+
+      class << self
+
+        def kind
+          name.underscore
+        end
+
+        # Returns the binding to be used in sub classes of Address
+        def get_binding
+          binding
+        end
+
+        # Helper class method to look up all addresss for
+        # addressable class name and addressable id.
+        def find_address_for_addressable(addressable_str, addressable_id)
+          find(:all,
+            :conditions => ["addressable_type = ? AND addressable_id = ?", addressable_str, addressable_id],
+            :order => "created_at DESC"
+          )
+        end
+
+        # Helper class method to look up a addressable object
+        # given the addressable class name and id
+        def find_addressable(addressable_str, addressable_id)
+          addressable_str.constantize.find(addressable_id)
+        end
+
+        # TODO not used
+        def translate_column_key(in_column)
+          out_column = class_variable_get("@@#{in_column}")
+          case out_column.class.name
+          when /NilClass/ then in_column
+          when /FalseClass/ then nil
+          else out_column
+          end
+        end
+
+        def content_column_names
+          content_columns.map(&:name) - %w(kind addressable_type addressable_id updated_at created_at)
+        end
+
+      end
+
+      #--- instance methods
+
+      # geokit getter
+      # returns a hash of geokit compatible GeoKit::Location attributes
+      def geokit_attributes
+        {
+          :zip => self.postal_code,
+          :city => self.city,
+          :street_address => self.street_address,
+          :state => self.province_code || self.province,
+          :country_code => self.country_code
+        }
+      end
+
+      # geokit setter
+      def geokit_attributes=(geo_attr)
+        self.attributes = {
+          :postal_code => geo_attr[:zip],
+          :city => geo_attr[:city],
+          :street_address => geo_attr[:street_address],
+          :province_code => geo_attr[:state],
+          :country_code => geo_attr[:country_code]
+        }
+      end
+
+      # attributes for active merchant address
+      def merchant_attributes(options={})
+        {
+          :name => self.name,
+          :address1 => self.address_line_1,
+          :address2 => self.address_line_2,
+          :city => self.city,
+          :state => (self.province_code || self.province),
+          :country => (self.country_code || self.country),
+          :zip => self.postal_code,
+          :phone => self.phone
+        }.merge(options)
+      end
+      alias_method :to_merchant_attributes, :merchant_attributes
+
+      # getter
+      def street
+        self[street_address_column]
+      end
+      alias_method :street_address, :street
+
+      # setter
+      def street=(a_street)
+        self[street_address_column] = a_street
+      end
+      alias_method :street_address=, :street=
+
+      # postal_code reader
+      def postal_code
+        self[postal_code_column]
+      end
+      alias_method :zip, :postal_code
+
+      # postal_code instead of ZIP
+      def postal_code=(a_zip)
+        self[postal_code_column] = a_zip
+      end
+      alias_method :zip=, :postal_code=
+
+      # address_line_1 getter, first line of street_address
+      # address1 alias for active merchant
+      def address_line_1
+        (self.street.gsub(/\r/, '').split(/\n/)[0] || self.street).strip if self.street
+      end
+      alias_method :address1, :address_line_1
+
+      # setter
+      def address_line_1=(addr1)
+        self.street = "#{addr1}\n#{address_line_2}"
+      end
+      alias_method :address1=, :address_line_1=
+
+      # address_line_2 getter, second line and following of street
+      # address2 alias for active merchant
+      def address_line_2
+        self.street.gsub(/\r/, '').split(/\n/)[1] if self.street
+      end
+      alias_method :address2, :address_line_2
+
+      # setter
+      def address_line_2=(addr2)
+        self.street = "#{address_line_1}\n#{addr2}"
+      end
+      alias_method :address2=, :address_line_2=
+
+      # province getter
+      def province
+        self[province_column]
+      end
+      alias_method :state, :province
+
+      # province setter
+      def province=(a_province)
+        self[province_column] = a_province
+      end
+      alias_method :state=, :province=
+
+      # province code getter
+      def province_code
+        self[province_code_column] if province_code?
+      end
+
+      def self.province_code?
+        return true if province_code_column
+        false
+      end
+
+      def province_code?
+        return true if province_code_column
+        false
+      end
+
+      # province code setter
+      def province_code=(a_province_code)
+        self[province_code_column] = a_province_code if province_code?
+      end
+
+      # country getter
+      def country
+        self[country_column]
+      end
+
+      # country setter
+      def country=(a_country)
+        self[country_column] = a_country
+      end
+
+      # country code getter
+      def country_code
+        self[country_code_column] if country_code?
+      end
+
+      def country_code?
+        return true if country_code_column
+        false
+      end
+
+      # country code setter
+      def country_code=(a_country_code)
+        self[country_code_column] = a_country_code if country_code?
+      end
+
+      # getter
+      def first_name
+        self[first_name_column] if first_name?
+      end
+      alias_method :firstname, :first_name
+
+      def first_name?
+        return true if first_name_column
+        false
+      end
+
+      # setter
+      def first_name=(a_first_name)
+        self[first_name_column] = a_first_name if first_name?
+      end
+      alias_method :firstname=, :first_name=
+
+      # getter
+      def last_name
+        self[last_name_column] if last_name?
+      end
+      alias_method :lastname, :last_name
+
+      def last_name?
+        return true if last_name_column
+        false
+      end
+
+      # setter
+      def last_name=(a_last_name)
+        self[last_name_column] = a_last_name if last_name?
+      end
+      alias_method :lastname=, :last_name=
+
+      # getter
+      def middle_name
+        self[middle_name_column] if middle_name?
+      end
+      alias_method :middlename, :middle_name
+
+      def self.middle_name?
+        return true if middle_name_column
+        false
+      end
+
+      def middle_name?
+        return true if middle_name_column
+        false
+      end
+
+      # setter
+      def middle_name=(a_middle_name)
+        self[middle_name_column] = a_middle_name if middle_name?
+      end
+
+      # setter
+      def gender=(a_gender)
+        if gender?
+          if a_gender.is_a? Symbol
+            self[gender_column] = case a_gender
+            when :male then 'm'
+            when :female then 'f'
+            else ''
+            end
+          elsif a_gender.is_a? String
+            self[gender_column] = case a_gender
+            when 'm' then 'm'
+            when 'f' then 'f'
+            else ''
+            end
+          end
+        end
+      end
+
+      # gender getter
+      def gender
+        self[gender_column] if gender?
+      end
+
+      def gender?
+        return true if gender_column
+        false
+      end
+
+      def is_gender_male?
+        self.gender == 'm'
+      end
+
+      def is_gender_female?
+        self.gender == 'f'
+      end
+
+      # Concatenates First-, Middle-, last_name to one string
+      def name
+        result = []
+        result << first_name
+        result << middle_name
+        result << last_name
+        result = result.compact.map {|m| m.to_s.strip }.reject {|i| i.empty? }
+        return result.join(' ') unless result.empty?
+      end
+
+      # Similar as in Person, only displays like "Mr" or "Prof. Dr."
+      def salutation(options={})
+        (self.is_gender_male? ? (return "Mr") : (return "Ms")) if self.gender
+        ''
+      end
+      alias_method :salutation_display, :salutation
+
+      # Returns the salutation and name, like "Prof. Dr. Thomas Mann" or "Mr Adam Smith"
+      def salutation_and_name
+        "#{salutation} #{name}".strip
+      end
+      alias_method :salutation_and_name_display, :salutation_and_name
+
+      # returns the province (as full text) or the province_code (e.g. CA)
+      def province_or_province_code
+        self.province.to_s.empty? ? self.province_code : self.province
+      end
+
+      # returns either the full country name or the country code (e.g. DE)
+      def country_or_country_code
+        self.country.to_s.empty? ? self.country_code : self.country
+      end
+
+      # Writes the address as comma delimited string
+      def to_s
+        result = []
+        result << self.address_line_1
+        result << self.address_line_2
+        result << self.city
+        result << self.province_or_province_code
+        result << self.postal_code
+        result << self.country_or_country_code
+        result.compact.map {|m| m.to_s.strip }.reject {|i| i.empty? }.join(", ")
+      end
+
+      # return only attributes with relevant content
+      def content_attributes
+        self.attributes.reject {|k,v| !self.content_column_names.include?(k.to_s)}.symbolize_keys
+      end
+
+      # returns content column name strings
+      def content_column_names
+        self.class.content_column_names
+      end
+
+      # E.g. :billing_addres, :shipping_address
+      def kind
+        self.class.kind
+      end
+    end
+  end
+end

data/lib/merchant_sidekick/addressable/addressable.rb

@@ -0,0 +1,353 @@
+module MerchantSidekick #:nodoc:
+  module Addressable #:nodoc:
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Addressable adds address associations in the following way:
+    #
+    #   * supports multiple types of addresses, e.g. BusinessAddress
+    #   * associations for each type
+    #   * adds scopes, finders and other helpers
+    #
+    # E.g.
+    #
+    #   class User < ActiveRecord::base
+    #     has_addresses :personal, :business, :billing
+    #     ...
+    #     # => @user.personal_addresses
+    #     # => @user.find_personal_address
+    #     # => @user.find_or_build_personal_address
+    #   end
+    #
+    # or
+    #
+    #   class User < ActiveRecord::base
+    #     has_address
+    #     ...
+    #     # => @user.address
+    #   end
+    #
+    #
+    #   class User < ActiveRecord::base
+    #     has_address :mailing
+    #     ...
+    #     # => @user.mailing_address
+    #     # => @user.find_mailing_address
+    #     # => @user.find_or_build_mailing_address
+    #   end
+    #
+    module ClassMethods
+
+      # Defines a single address or a single address per address type
+      def has_address(*arguments)
+        attributes, options = [], {:has_one => true, :has_many => false}
+        arguments.each do |argument|
+          case argument.class.name
+          when 'Hash'
+            options = options.merge(argument)
+          else
+            attributes << argument
+          end
+        end
+
+        if attributes.empty?
+          has_one :address, :as => :addressable, :dependent => :destroy,
+            :class_name => "MerchantSidekick::Addressable::Address"
+
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def build_address_with_addressable(attributes={}, options={})
+              build_address_without_addressable(attributes.merge(:addressable => self), options)
+            end
+            alias_method_chain :build_address, :addressable
+
+            def address_attributes=(attributes)
+              self.address ? self.address.attributes = attributes : self.build_address(attributes)
+            end
+          END
+        else
+          attributes.each do |attribute|
+            # Address decendent
+            # Note: the <attribute>.pluralize.classify makes sure that classify works
+            #       for singular attribute, e.g. :business -> BusinessAddress, otherwise,
+            #       Rails default would inflect :business -> BusinesAddress
+            address_class = <<-ADDRESS
+            class #{attribute.to_s.pluralize.classify}Address < MerchantSidekick::Addressable::Address
+              def self.kind
+                '#{attribute}'.to_sym
+              end
+
+              #{ attributes.collect {|a| "def self.#{a}?; #{a == attribute ? 'true' : 'false'}; end" }.join("\n") }
+
+              def kind
+                '#{attribute}'.to_sym
+              end
+
+              #{ attributes.collect {|a| "def #{a}?; #{a == attribute ? 'true' : 'false'}; end" }.join("\n") }
+            end
+            ADDRESS
+            eval address_class, TOPLEVEL_BINDING
+
+            has_one "#{attribute}_address".to_sym,
+            :class_name => "#{attribute.to_s.pluralize.classify}Address",
+            :as => :addressable,
+            :dependent => :destroy
+
+            class_eval(<<-END, __FILE__, __LINE__+1)
+              def build_#{attribute}_address_with_addressable(attributes={}, options={})
+                build_#{attribute}_address_without_addressable(attributes.merge(:addressable => self), options)
+              end
+              alias_method_chain :build_#{attribute}_address, :addressable
+
+              def find_#{attribute}_address(options={})
+                find_address(:#{attribute}, options)
+              end
+
+              def find_default_#{attribute}_address
+                find_default_address(:#{attribute})
+              end
+              alias_method :default_#{attribute}_address, :find_default_#{attribute}_address
+
+              def find_or_build_#{attribute}_address(options={})
+                find_or_build_address(:#{attribute}, options)
+              end
+
+              def find_#{attribute}_address_or_clone_from(from_address, options={})
+                find_or_clone_address(:#{attribute}, from_address, options)
+              end
+
+              def #{attribute}_address_attributes=(attributes)
+                self.#{attribute}_address ? self.#{attribute}_address.attributes = attributes : self.build_#{attribute}_address(attributes)
+              end
+            END
+          end
+        end
+
+        class_attribute :acts_as_addressable_options, :instance_writer => false
+        self.acts_as_addressable_options = {
+          :attributes       => attributes,
+          :association_type => options[:has_one] ? :has_one : :has_many
+        }
+
+        include MerchantSidekick::Addressable::InstanceMethods
+        extend MerchantSidekick::Addressable::SingletonMethods
+      end
+
+      # Defines a single address or a single address per address type
+      def has_addresses(*arguments)
+        attributes, options = [], {:has_one => false, :has_many => true}
+        arguments.each do |argument|
+          case argument.class.name
+          when 'Hash'
+            options = defaults.merge(argument)
+          else
+            attributes << argument
+          end
+        end
+
+        has_many :addresses, :as => :addressable, :dependent => :destroy,
+        :class_name => "MerchantSidekick::Addressable::Address"
+
+        attributes.each do |attribute|
+          address_class = <<-ADDRESS
+            class #{attribute.to_s.pluralize.classify}Address < MerchantSidekick::Addressable::Address
+              def self.kind
+                '#{attribute}'.to_sym
+              end
+
+              #{ attributes.collect {|a| "def self.#{a}?; #{a == attribute ? 'true' : 'false'}; end" }.join("\n") }
+
+              def kind
+                '#{attribute}'.to_sym
+              end
+
+              #{ attributes.collect {|a| "def #{a}?; #{a == attribute ? 'true' : 'false'}; end" }.join("\n") }
+            end
+          ADDRESS
+          eval address_class, TOPLEVEL_BINDING
+
+          has_many "#{attribute.to_s.classify}Address".pluralize.underscore.to_sym,
+          :class_name => "#{attribute.to_s.pluralize.classify}Address",
+          :as => :addressable,
+          :dependent => :destroy
+
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def find_#{attribute}_addresses(options={})
+              find_addresses(:all, :#{attribute}, options)
+            end
+
+            def find_default_#{attribute}_address
+              find_default_address(:#{attribute})
+            end
+            alias_method :default_#{attribute}_address, :find_default_#{attribute}_address
+
+            def find_or_build_#{attribute}_address(options={})
+              find_or_build_address(:#{attribute}, options)
+            end
+
+            def find_#{attribute}_address_or_clone_from(from_address, options={})
+              find_or_clone_address(:#{attribute}, from_address, options)
+            end
+          END
+        end
+
+        class_attribute :acts_as_addressable_options, :instance_writer => false
+        self.acts_as_addressable_options = {
+          :attributes       => attributes,
+          :association_type => options[:has_one] ? :has_one : :has_many
+        }
+
+        include MerchantSidekick::Addressable::InstanceMethods
+        extend MerchantSidekick::Addressable::SingletonMethods
+      end
+
+    end
+
+    # This module contains class methods
+    module SingletonMethods
+
+      # Helper method to lookup for addresses for a given object.
+      # Example:
+      #   Address.find_address_for a_customer_instance
+      def find_all_addresses_for(obj)
+        addressable = ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s
+        Address.find(
+        :all,
+        :conditions => ["addressable_id = ? AND addressable_type = ?", obj.id, addressable]
+        )
+      end
+
+    end
+
+    # This module contains instance methods
+    module InstanceMethods
+
+      # addressable.find_addresses(:first, :billing, conditions)
+      def find_addresses(selector, kind, options = {})
+        defaults = {:order => "created_at DESC"}
+        options = defaults.merge(options).symbolize_keys
+
+        if :has_one == acts_as_addressable_options[:association_type]
+          conditions = options[:conditions] || ''
+          scoped = Address.scoped
+          scoped = scoped.where("addressable_id = ? AND addressable_type = ? AND type LIKE ?",
+          self.id, self.class.base_class.name, "#{kind.to_s.pluralize.classify}Address")
+          scoped = scoped.where(conditions) unless conditions.blank?
+          options.merge!(:conditions => conditions)
+          scoped.send(selector)
+        elsif :has_many == acts_as_addressable_options[:association_type]
+          self.send("#{kind}_addresses").find(selector, options)
+        end
+      end
+
+      def find_address(kind, options={})
+        find_addresses(:first, kind, options)
+      end
+
+      # returns the default address for either :has_one or :has_many
+      # address definitions
+      # Usage:
+      #   find_default_address :billing
+      #
+      def find_default_address(kind=nil)
+        kind ||= auto_kind
+        kind = kind.to_sym
+        if :has_one == acts_as_addressable_options[:association_type]
+          if acts_as_addressable_options[:attributes].empty?
+            self.address
+          else
+            self.send("#{kind}_address")
+          end
+        elsif :has_many == acts_as_addressable_options[:association_type]
+          if acts_as_addressable_options[:attributes].empty?
+            self.addresses.find(:first, :order => "udpated_at DESC")
+          else
+            self.send("#{kind}_addresses").find(:first, :order => "udpated_at DESC")
+          end
+        end
+      end
+
+      # Find address of kind 'type' or instantiate a new address to relationship.
+      # Optionally, submit attributes to instantiate the address with.
+      # Examples:
+      #   find_or_build_address :business
+      #   find_or_build_address :business, :street => "100 Infinity Loop"
+      #   find_or_build_address :street => "100 Infinity Loop"
+      def find_or_build_address(*args)
+        options = {}
+        attributes = []
+        # if first argument, it determines the type => :kind
+        args.each do |argument|
+          case argument.class.name
+          when /Symbol/, /String/
+            attributes << argument
+          when /Hash/
+            options.merge!( argument )
+          end
+        end
+        kind = attributes.first
+        unless address = find_address(kind, :conditions => options)
+          if :has_one == acts_as_addressable_options[:association_type]
+            if acts_as_addressable_options[:attributes].empty?
+              address = self.build_address(options)
+            else
+              address = self.send("build_#{kind}_address", options)
+            end
+          else
+            if acts_as_addressable_options[:attributes].empty?
+              address = self.addresses.build(options)
+            else
+              address = self.send("#{kind}_addresses").build(options)
+            end
+          end
+        end
+        address
+      end
+
+      # Used for finding the billing address if none is present
+      # the billing address is cloned from business address and
+      # if that is not found then a new billing address is created
+      # Usage:
+      #   find_or_clone_address :billing, an_address, { :company_name => "Bla Inc." }
+      # or
+      #   find_or_clone_address :billing, :shipping   # finds billing or copies from shipping address
+      #
+      def find_or_clone_address(to_type, from_address=nil, options={})
+        unless to_address = find_default_address(to_type)
+          if from_address.nil?
+            from_address = "#{to_type}_address".camelize.constantize.new(options)
+          elsif from_address.is_a? Symbol
+            from_address = find_default_address(from_address)
+          elsif from_address.is_a? Hash
+            from_address = "#{to_type}_address".camelize.constantize.new(from_address)
+          end
+          if from_address
+            if :has_one == acts_as_addressable_options[:association_type]
+              to_address = self.send("build_#{to_type}_address", from_address.content_attributes)
+            elsif :has_many == acts_as_addressable_options[:association_type]
+              to_address = self.send("#{to_type}_addresses").build from_address.content_attributes
+            end
+          end
+        end
+        to_address
+      end
+
+      private
+
+      def auto_kind
+        if :has_one==acts_as_addressable_options[:association_type]
+          if acts_as_addressable_options[:attributes].empty?
+            :address
+          else
+            acts_as_addressable_options[:attributes].first
+          end
+        else
+          acts_as_addressable_options[:attributes].first
+        end
+      end
+
+    end
+
+  end
+end