acts_as_geocodable 1.0.4 → 2.0.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+2.0.0 - 2010-10-01
+* Rewritten for Rails 3
+* New Rails 3/ARel finder syntax
+* Double Rainbows
+
 0.2.1 - 2008-8-8
 * Results are now WillPaginate compatible
 

data/README

@@ -1,58 +1,53 @@
 = acts_as_geocodable
 
-acts_as_geocodable is a plugin to help build geo-aware applications. It automatically geocodes your models when they are saved, giving you the ability to search by location and calculate distances between records.
+acts_as_geocodable helps you build geo-aware applications. It automatically geocodes your models when they are saved, giving you the ability to search by location and calculate distances between records.
+
+Beginning with version 2, we require Rails 3.  Use one of the 1.0.x tags to work with Rails 2.3.
+
+Also, we've adopted the ARel style syntax for finding records.
 
 == Usage
 
   event = Event.create :street => "777 NE Martin Luther King, Jr. Blvd.",
     :locality => "Portland", :region => "Oregon", :postal_code => 97232
-    
+
   event.geocode.latitude                                #=> 45.529100000000
   event.geocode.longitude                               #=> -122.644200000000
-  
-  event.distance_to "49423"                             #=> 1807.66560483205
-  
-  Event.find(:all, :within => 50, :origin => "97232")
-  
-  Event.find(:nearest, :origin => "Portland, OR")
-  
-== Upgrading
-
-If you're upgrading from a previous version of this plugin, note that :city has been renamed to :locality to be consistent with Graticule 0.2.  Create a migration that has:
 
-  rename_column :geocodes, :city, :locality
+  event.distance_to "49423"                             #=> 1807.66560483205
 
-Also remember to change your mapping in your geocodable classes to use the :locality key instead of :city:
+  Event.origin("97232", :within => 50)
 
-class Event < ActiveRecord::Base
-	acts_as_geocodable :address => {:street => :address1, :locality => :city,
-	  :region => :state, :postal_code => :zip}
-end
+  Event.origin("Portland, OR").nearest
 
 == Installation
 
-Graticule[link:http://rubyforge.org/projects/graticule] is used for all the heavy lifting.
+Install as a gem
 
-  gem install graticule --include-dependencies
+  gem install acts_as_geocodable
 
-Install as a plugin
-
-  script/plugin install git://github.com/collectiveidea/acts_as_geocodable.git
-  
-Or, install as a gem
-  
-  gem install acts_as_geocodable --source=http://gemcutter.org
-  
+Graticule[link:http://rubyforge.org/projects/graticule] is used for all the heavy lifting and will be installed too.
 
 == Upgrading
-  
+
 Before October 2008, precision wasn't included in the Geocode model. Make sure you add a string precision column to your geocode table if you're upgrading from an older version, and update Graticule.
 
+Also, if you're upgrading from a previous version of this plugin, note that :city has been renamed to :locality to be consistent with Graticule 0.2.  Create a migration that has:
+
+  rename_column :geocodes, :city, :locality
+
+Also remember to change your mapping in your geocodable classes to use the :locality key instead of :city:
+
+class Event < ActiveRecord::Base
+  acts_as_geocodable :address => {:street => :address1, :locality => :city,
+    :region => :state, :postal_code => :zip}
+end
+
 == Configuration
 
 Create the required tables
-  
-  script/generate geocodable_migration add_geocodable_tables
+
+  rails generate acts_as_geocodable
   rake db:migrate
 
 Set the default geocoder in your environment.rb file.
@@ -62,13 +57,13 @@ Set the default geocoder in your environment.rb file.
 Then, in each model you want to make geocodable, add acts_as_geocodable.
 
   class Event < ActiveRecord::Base
-  	acts_as_geocodable
+    acts_as_geocodable
   end
 
 The only requirement is that your model must have address fields. By default, acts_as_geocodable looks for attributes called +street+, +locality+, +region+, +postal_code+, and +country+.  To change these, you can provide a mapping in the <tt>:address</tt> option:
 
   class Event < ActiveRecord::Base
-  	acts_as_geocodable :address => {:street => :address1, :locality => :city, :region => :state, :postal_code => :zip}
+    acts_as_geocodable :address => {:street => :address1, :locality => :city, :region => :state, :postal_code => :zip}
   end
 
 If that doesn't meet your needs, simply override the default +to_location+ method in your model, and return a Graticule::Location with those attributes set.
@@ -76,7 +71,7 @@ If that doesn't meet your needs, simply override the default +to_location+ metho
 acts_as_geocodable can also update your address fields with the data returned from the geocoding service:
 
   class Event < ActiveRecord::Base
-  	acts_as_geocodable :normalize_address => true
+    acts_as_geocodable :normalize_address => true
   end
 
 == IP-based Geocoding
@@ -84,8 +79,8 @@ acts_as_geocodable can also update your address fields with the data returned fr
 acts_as_geocodable adds a remote_location method in your controllers that uses http://hostip.info to guess remote users location based on their IP address.
 
   def index
-    @nearest = Store.find(:nearest, :origin => remote_location) if remote_location
-    @stores = Store.find(:all)
+    @nearest = Store.origin(remote_location).nearest if remote_location
+    @stores = Store.all
   end
 
 Keep in mind that IP-based geocoding is not always accurate, and often will not return any results.
@@ -100,5 +95,4 @@ Patches and suggestions are welcome!
 
 == To Do
 
-* Documentation!!!
 * configurable formulas

data/lib/acts_as_geocodable.rb

@@ -1,307 +1,262 @@
+require 'graticule'
 require 'acts_as_geocodable/geocoding'
 require 'acts_as_geocodable/geocode'
 require 'acts_as_geocodable/remote_location'
 
-module CollectiveIdea #:nodoc:
-  module Acts #:nodoc:
-    module Geocodable #:nodoc:
-      
-      def self.included(mod)
-        mod.extend(ClassMethods)
+module ActiveSupport::Callbacks::ClassMethods
+  def without_callback(*args, &block)
+    skip_callback(*args)
+    yield
+    set_callback(*args)
+  end
+end
+
+module ActsAsGeocodable #:nodoc:
+  # Make a model geocodable.
+  #
+  #  class Event < ActiveRecord::Base
+  #    acts_as_geocodable
+  #  end
+  #
+  # == Options
+  # * <tt>:address</tt>: A hash that maps geocodable attirbutes (<tt>:street</tt>,
+  #   <tt>:locality</tt>, <tt>:region</tt>, <tt>:postal_code</tt>, <tt>:country</tt>)
+  #   to your model's address fields, or a symbol to store the entire address in one field
+  # * <tt>:normalize_address</tt>: If set to true, you address fields will be updated
+  #   using the address fields returned by the geocoder. (Default is +false+)
+  # * <tt>:units</tt>: Default units-<tt>:miles</tt> or <tt>:kilometers</tt>-used for
+  #   distance calculations and queries. (Default is <tt>:miles</tt>)
+  #
+  def acts_as_geocodable(options = {})
+    options = {
+      :address => {
+        :street => :street, :locality => :locality, :region => :region,
+        :postal_code => :postal_code, :country => :country},
+      :normalize_address => false,
+      :distance_column => 'distance',
+      :units => :miles
+    }.merge(options)
+
+    write_inheritable_attribute :acts_as_geocodable_options, options
+    class_inheritable_reader :acts_as_geocodable_options
+
+    define_callbacks :geocoding
+
+    has_one :geocoding, :as => :geocodable, :include => :geocode, :dependent => :destroy
+
+    after_save :attach_geocode
+
+    # Would love to do a simpler scope here, like:
+    # scope :with_geocode_fields, includes(:geocoding)
+    # But we need to use select() and it would get overwritten.
+    scope :with_geocode_fields, lambda {
+      joins("JOIN geocodings ON
+          #{table_name}.#{primary_key} = geocodings.geocodable_id AND
+            geocodings.geocodable_type = '#{model_name}'
+          JOIN geocodes ON geocodings.geocode_id = geocodes.id")
+    }
+
+    # Use ActiveRecord ARel style syntax for finding records.
+    #
+    #   Model.origin("Chicago, IL", :within => 10)
+    #
+    # a +distance+ attribute indicating the distance
+    # to the origin is added to each of the results:
+    #
+    #   Model.origin("Portland, OR").first.distance #=> 388.383
+    #
+    # == Options
+    #
+    # * <tt>origin</tt>: A Geocode, String, or geocodable model that specifies
+    #   the origin
+    # * <tt>:within</tt>: Limit to results within this radius of the origin
+    # * <tt>:beyond</tt>: Limit to results outside of this radius from the origin
+    # * <tt>:units</tt>: Units to use for <tt>:within</tt> or <tt>:beyond</tt>.
+    #   Default is <tt>:miles</tt> unless specified otherwise in the +acts_as_geocodable+
+    #   declaration.
+    #
+    scope :origin, lambda {|*args|
+      origin = args[0]
+      options = {
+        :units => acts_as_geocodable_options[:units],
+      }.merge(args[1] || {})
+      distance_sql = sql_for_distance(origin, options[:units])
+
+      scope = with_geocode_fields.select("#{table_name}.*, #{distance_sql} AS
+           #{acts_as_geocodable_options[:distance_column]}")
+
+      scope = scope.where("#{distance_sql} >  #{options[:beyond]}") if options[:beyond]
+      scope = scope.where("#{distance_sql} <= #{options[:within]}") if options[:within]
+      scope
+    }
+
+    scope :near, order("#{acts_as_geocodable_options[:distance_column]} ASC")
+    scope :far, order("#{acts_as_geocodable_options[:distance_column]} DESC")
+
+    include ActsAsGeocodable::Model
+  end
+
+  module Model
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Find the nearest location to the given origin
+      #
+      #   Model.origin("Grand Rapids, MI").nearest
+      #
+      def nearest
+        near.first
       end
 
-      module ClassMethods
-        
-        # Make a model geocodable.
-        #
-        #  class Event < ActiveRecord::Base
-        #    acts_as_geocodable
-        #  end
-        #
-        # == Options
-        # * <tt>:address</tt>: A hash that maps geocodable attirbutes (<tt>:street</tt>,
-        #   <tt>:locality</tt>, <tt>:region</tt>, <tt>:postal_code</tt>, <tt>:country</tt>)
-        #   to your model's address fields, or a symbol to store the entire address in one field
-        # * <tt>:normalize_address</tt>: If set to true, you address fields will be updated
-        #   using the address fields returned by the geocoder. (Default is +false+)
-        # * <tt>:units</tt>: Default units-<tt>:miles</tt> or <tt>:kilometers</tt>-used for
-        #   distance calculations and queries. (Default is <tt>:miles</tt>)
-        #
-        def acts_as_geocodable(options = {})
-          options = {
-            :address => {
-              :street => :street, :locality => :locality, :region => :region,
-              :postal_code => :postal_code, :country => :country},
-            :normalize_address => false,
-            :distance_column => 'distance',
-            :units => :miles
-          }.merge(options)
-          
-          write_inheritable_attribute :acts_as_geocodable_options, options
-          class_inheritable_reader :acts_as_geocodable_options
-          
-          define_callbacks :after_geocoding
-          
-          has_one :geocoding, :as => :geocodable, :include => :geocode, :dependent => :destroy
-          
-          after_save :attach_geocode          
-          
-          include CollectiveIdea::Acts::Geocodable::InstanceMethods
-          extend CollectiveIdea::Acts::Geocodable::SingletonMethods
-        end
-        
+      # Find the farthest location to the given origin
+      #
+      #   Model.origin("Grand Rapids, MI").farthest
+      #
+      def farthest
+        far.first
       end
 
-      module SingletonMethods
-        
-        # Extends ActiveRecord's find method to be geo-aware.
-        #
-        #   Model.find(:all, :within => 10, :origin => "Chicago, IL")
-        #
-        # Whenever find is called with an <tt>:origin</tt>, a +distance+ attribute
-        # indicating the distance to the origin is added to each of the results:
-        #
-        #   Model.find(:first, :origin => "Portland, OR").distance #=> 388.383
-        #
-        # +acts_as_geocodable+ adds 2 other retrieval approaches to ActiveRecord's default
-        # find by id, find <tt>:first</tt>, and find <tt>:all</tt>:
-        #
-        # * <tt>:nearest</tt>: find the nearest location to the given origin
-        # * <tt>:farthest</tt>: find the farthest location from the given origin
-        #
-        #   Model.find(:nearest, :origin => "Grand Rapids, MI")
-        #
-        # == Options
-        #
-        # * <tt>:origin</tt>: A Geocode, String, or geocodable model that specifies
-        #   the origin
-        # * <tt>:within</tt>: Limit to results within this radius of the origin
-        # * <tt>:beyond</tt>: Limit to results outside of this radius from the origin
-        # * <tt>:units</tt>: Units to use for <tt>:within</tt> or <tt>:beyond</tt>.
-        #   Default is <tt>:miles</tt> unless specified otherwise in the +acts_as_geocodable+
-        #   declaration.
-        #
-        def find(*args)
-          options = args.extract_options!
-          origin = location_to_geocode options.delete(:origin)
-          if origin
-            options[:units] ||= acts_as_geocodable_options[:units]
-            add_distance_to_select!(origin, options)
-            with_proximity!(args, options) do
-              geocode_conditions!(options, origin) do
-                join_geocodes { super *args.push(options) }
-              end
-            end
-          else
-            super *args.push(options)
-          end
-        end
-        
-        # Extends ActiveRecord's count method to be geo-aware.
-        #
-        #   Model.count(:within => 10, :origin => "Chicago, IL")
-        #
-        # == Options
-        #
-        # * <tt>:origin</tt>: A Geocode, String, or geocodable model that specifies
-        #   the origin
-        # * <tt>:within</tt>: Limit to results within this radius of the origin
-        # * <tt>:beyond</tt>: Limit to results outside of this radius from the origin
-        # * <tt>:units</tt>: Units to use for <tt>:within</tt> or <tt>:beyond</tt>.
-        #   Default is <tt>:miles</tt> unless specified otherwise in the +acts_as_geocodable+
-        #   declaration.
-        #
-        def count(*args)
-          options = args.extract_options!
-          origin = location_to_geocode options.delete(:origin)
-          if origin
-            options[:units] ||= acts_as_geocodable_options[:units]
-            with_proximity!(args, options) do
-              geocode_conditions!(options, origin) do
-                join_geocodes { super *args.push(options) }
-              end
-            end
-          else
-            super *args.push(options)
-          end
-        end
-  
-        # Convert the given location to a Geocode
-        def location_to_geocode(location)
-          case location
-          when Geocode then location
-          when InstanceMethods then location.geocode
-          when String, Fixnum then Geocode.find_or_create_by_query(location)
-          end
+      # Convert the given location to a Geocode
+      def location_to_geocode(location)
+        case location
+        when Geocode then location
+        when InstanceMethods then location.geocode
+        when String, Fixnum then Geocode.find_or_create_by_query(location)
         end
-        
-        # Validate that the model can be geocoded
-        #
-        # Options:
-        # * <tt>:message</tt>: Added to errors base (Default: Address could not be geocoded.)
-        # * <tt>:allow_nil</tt>: If all the address attributes are blank, then don't try to
-        #   validate the geocode (Default: false)
-        # * <tt>:precision</tt>: Require a minimum geocoding precision
-        #
-        # validates_as_geocodable also takes a block that you can use to performa additional
-        # checks on the geocode. If this block returns false, then validation will fail.
-        #
-        #   validates_as_geocodable do |geocode|
-        #     geocode.country == "US"
-        #   end
-        #
-        def validates_as_geocodable(options = {})
-          options = options.reverse_merge :message => "Address could not be geocoded.", :allow_nil => false
-          validate do |model|
-            is_blank = model.to_location.attributes.except(:precision).all?(&:blank?)
-            unless options[:allow_nil] && is_blank
-              geocode = model.send :attach_geocode
-              if !geocode ||
-                  (options[:precision] && geocode.precision < options[:precision]) ||
-                  (block_given? && yield(geocode) == false)
-                model.errors.add_to_base options[:message]
-              end
-            end
-          end
-        end
-        
-      private
-      
-        def add_distance_to_select!(origin, options)
-          (options[:select] ||= "#{table_name}.*") <<
-            ", #{sql_for_distance(origin, options[:units])} AS
-            #{acts_as_geocodable_options[:distance_column]}"
-        end
-      
-        def with_proximity!(args, options)
-          if [:nearest, :farthest].include?(args.first)
-            raise ArgumentError, ":include cannot be specified with :nearest and :farthest" if options[:include]
-            direction = args.first == :nearest ? "ASC" : "DESC"
-            args[0] = :first
-            with_scope :find => { :order => "#{acts_as_geocodable_options[:distance_column]} #{direction}"} do
-              yield
+      end
+
+      # Validate that the model can be geocoded
+      #
+      # Options:
+      # * <tt>:message</tt>: Added to errors base (Default: Address could not be geocoded.)
+      # * <tt>:allow_nil</tt>: If all the address attributes are blank, then don't try to
+      #   validate the geocode (Default: false)
+      # * <tt>:precision</tt>: Require a minimum geocoding precision
+      #
+      # validates_as_geocodable also takes a block that you can use to performa additional
+      # checks on the geocode. If this block returns false, then validation will fail.
+      #
+      #   validates_as_geocodable do |geocode|
+      #     geocode.country == "US"
+      #   end
+      #
+      def validates_as_geocodable(options = {})
+        options = options.reverse_merge :message => "Address could not be geocoded.", :allow_nil => false
+        validate do |model|
+          is_blank = model.to_location.attributes.except(:precision).all?(&:blank?)
+          unless options[:allow_nil] && is_blank
+            geocode = model.send :attach_geocode
+            if !geocode ||
+                (options[:precision] && geocode.precision < options[:precision]) ||
+                (block_given? && yield(geocode) == false)
+              model.errors.add :base, options[:message]
             end
-          else
-            yield
           end
         end
-        
-        def join_geocodes(&block)
-          with_scope :find => { :joins => "JOIN geocodings ON
-              #{table_name}.#{primary_key} = geocodings.geocodable_id AND
-                geocodings.geocodable_type = '#{class_name}'
-              JOIN geocodes ON geocodings.geocode_id = geocodes.id" } do
-            yield
-          end
-        end
-        
-        def geocode_conditions!(options, origin)
-          units = options.delete(:units)
-          conditions = []
-          conditions << "#{sql_for_distance(origin, units)} <= #{options.delete(:within)}" if options[:within]
-          conditions << "#{sql_for_distance(origin, units)} > #{options.delete(:beyond)}" if options[:beyond]
-          if conditions.empty?
-            yield
-          else
-            with_scope(:find => { :conditions => conditions.join(" AND ") }) { yield }
-          end
-        end
-        
-        def sql_for_distance(origin, units = acts_as_geocodable_options[:units])
-          Graticule::Distance::Spherical.to_sql(
-            :latitude => origin.latitude,
-            :longitude => origin.longitude,
-            :latitude_column => "geocodes.latitude",
-            :longitude_column => "geocodes.longitude",
-            :units => units
-          )
-        end
-        
       end
 
-      module InstanceMethods
-        
-        # Get the geocode for this model
-        def geocode
-          geocoding.geocode if geocoding
-        end
-        
-        # Create a Graticule::Location
-        def to_location
-          Graticule::Location.new.tap do |location|
-            [:street, :locality, :region, :postal_code, :country].each do |attr|
-              location.send "#{attr}=", geo_attribute(attr)
-            end
+    private
+
+      def sql_for_distance(origin, units = acts_as_geocodable_options[:units])
+        origin = location_to_geocode(origin)
+        Graticule::Distance::Spherical.to_sql(
+          :latitude => origin.latitude,
+          :longitude => origin.longitude,
+          :latitude_column => "geocodes.latitude",
+          :longitude_column => "geocodes.longitude",
+          :units => units
+        )
+      end
+    end
+
+    module InstanceMethods
+
+      # Get the geocode for this model
+      def geocode
+        geocoding.geocode if geocoding
+      end
+
+      # Create a Graticule::Location
+      def to_location
+        Graticule::Location.new.tap do |location|
+          [:street, :locality, :region, :postal_code, :country].each do |attr|
+            location.send "#{attr}=", geo_attribute(attr)
           end
         end
-        
-        # Get the distance to the given destination. The destination can be an
-        # acts_as_geocodable model, a Geocode, or a string
-        #
-        #   myhome.distance_to "Chicago, IL"
-        #   myhome.distance_to "49423"
-        #   myhome.distance_to other_model
-        #
-        # == Options
-        # * <tt>:units</tt>: <tt>:miles</tt> or <tt>:kilometers</tt>
-        # * <tt>:formula</tt>: The formula to use to calculate the distance. This can
-        #   be any formula supported by Graticule. The default is <tt>:haversine</tt>.
-        #  
-        def distance_to(destination, options = {})
-          units = options[:units] || acts_as_geocodable_options[:units]
-          formula = options[:formula] || :haversine
-          
-          geocode = self.class.location_to_geocode(destination)
-          self.geocode.distance_to(geocode, units, formula)
-        end
-        
-      protected
-        
-        # Perform the geocoding
-        def attach_geocode
-          new_geocode = Geocode.find_or_create_by_location self.to_location unless self.to_location.blank?
-          if new_geocode && self.geocode != new_geocode
+      end
+
+      # Get the distance to the given destination. The destination can be an
+      # acts_as_geocodable model, a Geocode, or a string
+      #
+      #   myhome.distance_to "Chicago, IL"
+      #   myhome.distance_to "49423"
+      #   myhome.distance_to other_model
+      #
+      # == Options
+      # * <tt>:units</tt>: <tt>:miles</tt> or <tt>:kilometers</tt>
+      # * <tt>:formula</tt>: The formula to use to calculate the distance. This can
+      #   be any formula supported by Graticule. The default is <tt>:haversine</tt>.
+      #
+      def distance_to(destination, options = {})
+        units = options[:units] || acts_as_geocodable_options[:units]
+        formula = options[:formula] || :haversine
+
+        geocode = self.class.location_to_geocode(destination)
+        self.geocode.distance_to(geocode, units, formula)
+      end
+
+    protected
+
+      # Perform the geocoding
+      def attach_geocode
+        new_geocode = Geocode.find_or_create_by_location self.to_location unless self.to_location.blank?
+        if new_geocode && self.geocode != new_geocode
+          run_callbacks :geocoding do
             self.geocoding = Geocoding.new :geocode => new_geocode
             self.update_address self.acts_as_geocodable_options[:normalize_address]
-            callback :after_geocoding
-          elsif !new_geocode && self.geocoding
-            self.geocoding.destroy
           end
-          new_geocode
-        rescue Graticule::Error => e
-          logger.warn e.message
+        elsif !new_geocode && self.geocoding
+          self.geocoding.destroy
         end
-        
-        
-        def update_address(force = false) #:nodoc:
-          unless self.geocode.blank?
-            if self.acts_as_geocodable_options[:address].is_a? Symbol
-              method = self.acts_as_geocodable_options[:address]
+        new_geocode
+      rescue Graticule::Error => e
+        logger.warn e.message
+      end
+
+
+      def update_address(force = false) #:nodoc:
+        unless self.geocode.blank?
+          if self.acts_as_geocodable_options[:address].is_a? Symbol
+            method = self.acts_as_geocodable_options[:address]
+            if self.respond_to?("#{method}=") && (self.send(method).blank? || force)
+              self.send "#{method}=", self.geocode.to_location.to_s
+            end
+          else
+            self.acts_as_geocodable_options[:address].each do |attribute,method|
               if self.respond_to?("#{method}=") && (self.send(method).blank? || force)
-                self.send "#{method}=", self.geocode.to_location.to_s
-              end
-            else
-              self.acts_as_geocodable_options[:address].each do |attribute,method|
-                if self.respond_to?("#{method}=") && (self.send(method).blank? || force)
-                  self.send "#{method}=", self.geocode.send(attribute)
-                end
+                self.send "#{method}=", self.geocode.send(attribute)
               end
             end
-            
-            update_without_callbacks
           end
-        end
-        
-        def geo_attribute(attr_key) #:nodoc:
-          if self.acts_as_geocodable_options[:address].is_a? Symbol
-            attr_name = self.acts_as_geocodable_options[:address]
-            attr_key == :street ? self.send(attr_name) : nil
-          else
-            attr_name = self.acts_as_geocodable_options[:address][attr_key]
-            attr_name && self.respond_to?(attr_name) ? self.send(attr_name) : nil
+
+          self.class.without_callback(:save, :after, :attach_geocode) do
+            save
           end
         end
       end
+
+      def geo_attribute(attr_key) #:nodoc:
+        if self.acts_as_geocodable_options[:address].is_a? Symbol
+          attr_name = self.acts_as_geocodable_options[:address]
+          attr_key == :street ? self.send(attr_name) : nil
+        else
+          attr_name = self.acts_as_geocodable_options[:address][attr_key]
+          attr_name && self.respond_to?(attr_name) ? self.send(attr_name) : nil
+        end
+      end
     end
   end
-end
+end
+
+ActiveRecord::Base.send :extend, ActsAsGeocodable