darrell-geokit 1.2.4.1 → 1.4.1.1

data/Manifest.txt

@@ -1,4 +1,4 @@
-.project
+History.txt
 Manifest.txt
 README.markdown
 Rakefile
@@ -10,8 +10,10 @@ test/test_base_geocoder.rb
 test/test_bounds.rb
 test/test_ca_geocoder.rb
 test/test_geoloc.rb
+test/test_geoplugin_geocoder.rb
 test/test_google_geocoder.rb
 test/test_google_reverse_geocoder.rb
+test/test_inflector.rb
 test/test_ipgeocoder.rb
 test/test_latlng.rb
 test/test_multi_geocoder.rb

data/README.markdown

@@ -8,15 +8,15 @@ The Geokit gem provides:
  * Rectangular bounds calculations: is a point within a given rectangular bounds?
  * Heading and midpoint calculations
 
-Combine this with gem with the [geokit-rails plugin](http://github.com/andre/geokit-rails/tree/master) to get location-based finders for your Rails app.
+Combine this gem with the [geokit-rails plugin](http://github.com/andre/geokit-rails/tree/master) to get location-based finders for your Rails app.
 
 * Geokit Documentation at Rubyforge [http://geokit.rubyforge.org](http://geokit.rubyforge.org).
 * Repository at Github: [http://github.com/andre/geokit-gem/tree/master](http://github.com/andre/geokit-gem/tree/master).
+* Follow the Google Group for updates and discussion on Geokit: [http://groups.google.com/group/geokit](http://groups.google.com/group/geokit) 
 
 ## INSTALL
 
-    gem sources -a http://gems.github.com
-    sudo gem install andre-geokit
+    sudo gem install geokit
 
 ## QUICK START
 
@@ -74,6 +74,12 @@ If you're using this gem by itself, here are the configuration options:
 		# See http://www.google.com/apis/maps/signup.html
 		# and http://www.google.com/apis/maps/documentation/#Geocoding_Examples
 		Geokit::Geocoders::google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
+		
+		# You can also set multiple API KEYS for different domains that may be directed to this same application.
+		# The domain from which the current user is being directed will automatically be updated for Geokit via
+		# the GeocoderControl class, which gets it's begin filter mixed into the ActionController.
+		# You define these keys with a Hash as follows:
+		#Geokit::Geocoders::google = { 'rubyonrails.org' => 'RUBY_ON_RAILS_API_KEY', 'ruby-docs.org' => 'RUBY_DOCS_API_KEY' }
 		    
 		# This is your username and password for geocoder.us.
 		# To use the free service, the value can be set to nil or false.  For 
@@ -90,6 +96,10 @@ If you're using this gem by itself, here are the configuration options:
 		# and http://geocoder.ca/?register=1
 		Geokit::Geocoders::geocoder_ca = false
 		
+		# require "external_geocoder.rb"
+		# Please see the section "writing your own geocoders" for more information.
+		# Geokit::Geocoders::external_key = 'REPLACE_WITH_YOUR_API_KEY'
+		
 		# This is the order in which the geocoders are called in a failover scenario
 		# If you only want to use a single geocoder, put a single symbol in the array.
 		# Valid symbols are :google, :yahoo, :us, and :ca.
@@ -97,6 +107,10 @@ If you're using this gem by itself, here are the configuration options:
 		# various geocoders.  Make sure you read up on relevant Terms of Use for each
 		# geocoder you are going to use.
 		Geokit::Geocoders::provider_order = [:google,:us]
+		
+		# The IP provider order. Valid symbols are :ip,:geo_plugin.
+		# As before, make sure you read up on relevant Terms of Use for each.
+		# Geokit::Geocoders::ip_provider_order = [:external,:geo_plugin,:ip]
 
 If you're using this gem with the [geokit-rails plugin](http://github.com/andre/geokit-rails/tree/master), the plugin
 creates a template with these settings and places it in `config/initializers/geokit_config.rb`.
@@ -110,14 +124,54 @@ creates a template with these settings and places it in `config/initializers/geo
 * Geonames - a free geocoder
 
 ### address geocoders that also provide reverse geocoding 
-* Google Geocoder - requires an API key. Also supports multiple results.
+* Google Geocoder - requires an API key. Also supports multiple results and bounding box/country code biasing.
 
 ### IP address geocoders 
 * IP Geocoder - geocodes an IP address using hostip.info's web service.
 * Geoplugin.net -- another IP address geocoder
 
+### Google Geocoder Tricks
+
+The Google Geocoder sports a number of useful tricks that elevate it a little bit above the rest of the currently supported geocoders. For starters, it returns a `suggested_bounds` property for all your geocoded results, so you can more easily decide where and how to center a map on the places you geocode. Here's a quick example:
+
+    irb> res = Geokit::Geocoders::GoogleGeocoder.geocode('140 Market St, San Francisco, CA')
+		irb> pp res.suggested_bounds
+		#<Geokit::Bounds:0x53b36c
+		 @ne=#<Geokit::LatLng:0x53b204 @lat=37.7968528, @lng=-122.3926933>,
+		 @sw=#<Geokit::LatLng:0x53b2b8 @lat=37.7905576, @lng=-122.3989885>>
+
+In addition, you can use viewport or country code biasing to make sure the geocoders prefers results within a specific area. Say we wanted to geocode the city of Syracuse in Italy. A normal geocoding query would look like this:
+
+		irb> res = Geokit::Geocoder::GoogleGeocoder.geocode('Syracuse')
+		irb> res.full_address
+		=> "Syracuse, NY, USA"
+	
+Not exactly what we were looking for. We know that Syracuse is in Italy, so we can tell the Google Geocoder to prefer results from Italy first, and then wander the Syracuses of the world. To do that, we have to pass Italy's ccTLD (country code top-level domain) to the `:bias` option of the `geocode` method. You can find a comprehensive list of all ccTLDs here: http://en.wikipedia.org/wiki/CcTLD.
+
+		irb> res = Geokit::Geocoder::GoogleGeocoder.geocode('Syracuse', :bias => 'it')
+		irb> res.full_address
+		=> "Syracuse, Italy"
+
+Alternatively, we can speficy the geocoding bias as a bounding box object. Say we wanted to geocode the Winnetka district in Los Angeles.
+
+		irb> res = Geokit::Geocoder::GoogleGeocoder.geocode('Winnetka')
+		irb> res.full_address
+		=> "Winnetka, IL, USA"
+	
+Not it. What we can do is tell the geocoder to return results only from in and around LA.
+
+		irb> la_bounds = Geokit::Geocoder::GoogleGeocoder.geocode('Los Angeles').suggested_bounds
+		irb> res = Geokit::Geocoder::GoogleGeocoder.geocode('Winnetka', :bias => la_bounds)
+		irb> res.full_address
+		=> "Winnetka, California, USA"
+
+
 ### The Multigeocoder
-* Multi Geocoder - provides failover for the physical location geocoders.
+Multi Geocoder - provides failover for the physical location geocoders, and also IP address geocoders. Its configured by setting Geokit::Geocoders::provider_order, and Geokit::Geocoders::ip_provider_order. You should call the Multi-Geocoder with its :geocode method, supplying one address parameter which is either a real street address, or an ip address. For example:
+
+		Geokit::Geocoders::MultiGeocoder.geocode("900 Sycamore Drive")
+
+		Geokit::Geocoders::MultiGeocoder.geocode("12.12.12.12")
 
 ## MULTIPLE RESULTS
 Some geocoding services will return multple results if the there isn't one clear result. 
@@ -159,6 +213,36 @@ geocoders.rb contains all the geocoder implemenations. All the gercoders
 inherit from a common base (class Geocoder) and implement the private method
 do_geocode.
 
+## WRITING YOUR OWN GEOCODERS
+
+If you would like to write your own geocoders, you can do so by requiring 'geokit' or 'geokit/geocoders.rb' in a new file and subclassing the base class (which is class "Geocoder").
+You must then also require such extenal file back in your main geokit configuration.
+
+	require "geokit"
+
+	module Geokit
+	  module Geocoders
+   		
+		# Should be overriden as Geokit::Geocoders::external_key in your configuration file
+	    @@external_key = 'REPLACE_WITH_YOUR_API_KEY'
+	    __define_accessors
+   
+		# Replace name 'External' (below) with the name of your custom geocoder class
+		# and use :external to specify this geocoder in your list of geocoders.
+	    class ExternalGeocoder < Geocoder
+	      private 
+	      def self.do_geocode(address, options = {})
+	        # Main geocoding method
+	      end
+
+	      def self.parse_http_resp(body) # :nodoc:
+	        # Helper method to parse http response. See geokit/geocoders.rb.
+	      end
+	    end
+	
+	  end
+	end
+
 ## GOOGLE GROUP
 
 Follow the Google Group for updates and discussion on Geokit: http://groups.google.com/group/geokit 

data/Rakefile

@@ -2,19 +2,21 @@
 
 require 'rubygems'
 require 'hoe'
-require './lib/geokit'
+require './lib/geokit.rb'
 
-Hoe.new('Geokit', Geokit::VERSION) do |p|
-  # p.rubyforge_name = 'Geokitx' # if different than lowercase project name
-  p.developer('Andre Lewis and Bill Eisenhauer', 'andre@earthcode.com / bill_eisenhauer@yahoo.com')
-end
+# undefined method `empty?' for nil:NilClass
+# /Library/Ruby/Site/1.8/rubygems/specification.rb:886:in `validate' 
+class NilClass
+  def empty?
+    true
+  end
+end 
 
-task :generate_gemspec do
-  system "rake debug_gem | grep -v \"(in \" > `basename \\`pwd\\``.gemspec"
+project=Hoe.new('geokit', Geokit::VERSION) do |p|
+  #p.rubyforge_name = 'geokit' # if different than lowercase project name
+  p.developer('Andre Lewis', 'andre@earthcode.com')
+  p.summary="Geokit provides geocoding and distance calculation in an easy-to-use API"
 end
 
-task :update_manifest do
-  system "touch Manifest.txt; rake check_manifest | grep -v \"(in \" | patch"
-end
 
 # vim: syntax=Ruby

data/lib/geokit.rb

@@ -1,5 +1,5 @@
 module Geokit
-  VERSION = '1.2.0'
+  VERSION = '1.4.1'
   # These defaults are used in Geokit::Mappable.distance_to and in acts_as_mappable
   @@default_units = :miles
   @@default_formula = :sphere
@@ -22,9 +22,9 @@ module Geokit
 end
 
 path = File.expand_path(File.dirname(__FILE__))
-$: <<  path unless $:.include?(path)
+$:.unshift path unless $:.include?(path)
 require 'geokit/geocoders'
 require 'geokit/mappable'
 
-# make old-style module name "GeoKit" equivilent to new-style "Geokit"
+# make old-style module name "GeoKit" equivalent to new-style "Geokit"
 GeoKit=Geokit

data/lib/geokit/geocoders.rb

@@ -37,6 +37,10 @@ module Geokit
       '%' + $1.unpack('H2' * $1.size).join('%').upcase
       end.tr(' ', '+')
     end
+    
+    def camelize(str)
+      str.split('_').map {|w| w.capitalize}.join
+    end
   end  
   
   # Contains a range of geocoders:
@@ -70,25 +74,37 @@ module Geokit
     @@geocoder_ca = false
     @@geonames = false
     @@provider_order = [:google,:us]
+    @@ip_provider_order = [:geo_plugin,:ip]
     @@logger=Logger.new(STDOUT)
     @@logger.level=Logger::INFO
+    @@domain = nil
     
-    [:yahoo, :google, :geocoder_us, :geocoder_ca, :geonames, :provider_order, :timeout, 
-     :proxy_addr, :proxy_port, :proxy_user, :proxy_pass,:logger].each do |sym|
-      class_eval <<-EOS, __FILE__, __LINE__
-        def self.#{sym}
-          if defined?(#{sym.to_s.upcase})
-            #{sym.to_s.upcase}
-          else
-            @@#{sym}
-          end
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
+    def self.__define_accessors
+      class_variables.each do |v| 
+        sym = v.to_s.delete("@").to_sym
+        unless self.respond_to? sym
+          module_eval <<-EOS, __FILE__, __LINE__
+            def self.#{sym}
+              value = if defined?(#{sym.to_s.upcase})
+                #{sym.to_s.upcase}
+              else
+                @@#{sym}
+              end
+              if value.is_a?(Hash)
+                value = (self.domain.nil? ? nil : value[self.domain]) || value.values.first
+              end
+              value
+            end
+          
+            def self.#{sym}=(obj)
+              @@#{sym} = obj
+            end
+          EOS
         end
-      EOS
+      end
     end
+
+    __define_accessors
     
     # Error which is thrown in the event a geocoding error occurs.
     class GeocodeError < StandardError; end
@@ -103,17 +119,16 @@ module Geokit
       # Main method which calls the do_geocode template method which subclasses
       # are responsible for implementing.  Returns a populated GeoLoc or an
       # empty one with a failed success code.
-      def self.geocode(address)  
-        res = do_geocode(address)
-        return res.success ? res : GeoLoc.new
+      def self.geocode(address, options = {}) 
+        res = do_geocode(address, options)
+        return res.nil? ? GeoLoc.new : res
       end  
-      
       # Main method which calls the do_reverse_geocode template method which subclasses
       # are responsible for implementing.  Returns a populated GeoLoc or an
       # empty one with a failed success code.
       def self.reverse_geocode(latlng)
         res = do_reverse_geocode(latlng)
-        return res.success ? res : GeoLoc.new        
+        return res.success? ? res : GeoLoc.new        
       end
       
       # Call the geocoder service using the timeout if configured.
@@ -157,8 +172,8 @@ module Geokit
       def self.inherited(clazz)
         class_name = clazz.name.split('::').last
         src = <<-END_SRC
-          def self.#{Geokit::Inflector.underscore(class_name)}(address)
-            #{class_name}.geocode(address)
+          def self.#{Geokit::Inflector.underscore(class_name)}(address, options = {})
+            #{class_name}.geocode(address, options)
           end
         END_SRC
         class_eval(src)
@@ -184,7 +199,7 @@ module Geokit
       private
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, options = {})
         raise ArgumentError('Geocoder.ca requires a GeoLoc argument') unless address.is_a?(GeoLoc)
         url = construct_request(address)
         res = self.call_geocoder_service(url)
@@ -226,7 +241,7 @@ module Geokit
     class UsGeocoder < Geocoder
 
       private
-      def self.do_geocode(address)
+      def self.do_geocode(address, options = {})
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
         
         query = (address_str =~ /^\d{5}(?:-\d{4})?$/ ? "zip" : "address") + "=#{Geokit::Inflector::url_escape(address_str)}"
@@ -274,7 +289,7 @@ module Geokit
       private 
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, options = {})
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
         url="http://api.local.yahoo.com/MapsService/V1/geocode?appid=#{Geokit::Geocoders::yahoo}&location=#{Geokit::Inflector::url_escape(address_str)}"
         res = self.call_geocoder_service(url)
@@ -298,6 +313,8 @@ module Geokit
           res.zip=doc.elements['//Zip'].text if doc.elements['//Zip'] && doc.elements['//Zip'].text != nil
           res.street_address=doc.elements['//Address'].text if doc.elements['//Address'] && doc.elements['//Address'].text != nil
           res.precision=doc.elements['//Result'].attributes['precision'] if doc.elements['//Result']
+          # set the accuracy as google does (added by Andruby)
+          res.accuracy=%w{unknown country state state city zip zip+4 street address building}.index(res.precision)
           res.success=true
           return res
         else 
@@ -318,7 +335,7 @@ module Geokit
       private 
       
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      def self.do_geocode(address, options = {})
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
         # geonames need a space seperated search string
         address_str.gsub!(/,/, " ")
@@ -383,16 +400,51 @@ module Geokit
       end  
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address)
+      #
+      # Supports viewport/country code biasing
+      #
+      # ==== OPTIONS
+      # * :bias - This option makes the Google Geocoder return results biased to a particular
+      #           country or viewport. Country code biasing is achieved by passing the ccTLD
+      #           ('uk' for .co.uk, for example) as a :bias value. For a list of ccTLD's, 
+      #           look here: http://en.wikipedia.org/wiki/CcTLD. By default, the geocoder
+      #           will be biased to results within the US (ccTLD .com).
+      #
+      #           If you'd like the Google Geocoder to prefer results within a given viewport,
+      #           you can pass a Geokit::Bounds object as the :bias value.
+      #
+      # ==== EXAMPLES
+      # # By default, the geocoder will return Syracuse, NY
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse').country_code # => 'US'
+      # # With country code biasing, it returns Syracuse in Sicily, Italy
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Syracuse', :bias => :it).country_code # => 'IT'
+      #
+      # # By default, the geocoder will return Winnetka, IL
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka').state # => 'IL'
+      # # When biased to an bounding box around California, it will now return the Winnetka neighbourhood, CA
+      # bounds = Geokit::Bounds.normalize([34.074081, -118.694401], [34.321129, -118.399487])
+      # Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka', :bias => bounds).state # => 'CA'
+      def self.do_geocode(address, options = {})
+        bias_str = options[:bias] ? construct_bias_string_from_options(options[:bias]) : ''
         address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        res = self.call_geocoder_service("http://maps.google.com/maps/geo?q=#{Geokit::Inflector::url_escape(address_str)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8")
+        res = self.call_geocoder_service("http://maps.google.com/maps/geo?q=#{Geokit::Inflector::url_escape(address_str)}&output=xml#{bias_str}&key=#{Geokit::Geocoders::google}&oe=utf-8")
         return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
         xml = res.body
         logger.debug "Google geocoding. Address: #{address}. Result: #{xml}"
-        return self.xml2GeoLoc(xml)        
+        return self.xml2GeoLoc(xml, address)        
       end
       
-      def self.xml2GeoLoc(xml)
+      def self.construct_bias_string_from_options(bias)
+        if bias.is_a?(String) or bias.is_a?(Symbol)
+          # country code biasing
+          "&gl=#{bias.to_s.downcase}"
+        elsif bias.is_a?(Bounds)
+          # viewport biasing
+          "&ll=#{bias.center.ll}&spn=#{bias.to_span.ll}"
+        end
+      end
+      
+      def self.xml2GeoLoc(xml, address="")
         doc=REXML::Document.new(xml)
 
         if doc.elements['//kml/Response/Status/code'].text == '200'
@@ -400,9 +452,9 @@ module Geokit
           # Google can return multiple results as //Placemark elements. 
           # iterate through each and extract each placemark as a geoloc
           doc.each_element('//Placemark') do |e|
-            extracted_geoloc = extract_placemark(e) # g is now an instance of Geoloc
+            extracted_geoloc = extract_placemark(e) # g is now an instance of GeoLoc
             if geoloc.nil? 
-              # first time through, geoloc is still nill, so we make it the geoloc we just extracted
+              # first time through, geoloc is still nil, so we make it the geoloc we just extracted
               geoloc = extracted_geoloc 
             else
               # second (and subsequent) iterations, we push additional 
@@ -441,8 +493,16 @@ module Geokit
         # Translate accuracy into Yahoo-style token address, street, zip, zip+4, city, state, country
         # For Google, 1=low accuracy, 8=high accuracy
         address_details=doc.elements['.//*[local-name() = "AddressDetails"]']
-        accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
-        res.precision=%w{unknown country state state city zip zip+4 street address building}[accuracy]
+        res.accuracy = address_details ? address_details.attributes['Accuracy'].to_i : 0
+        res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
+        
+        # google returns a set of suggested boundaries for the geocoded result
+        if suggested_bounds = doc.elements['//LatLonBox']  
+          res.suggested_bounds = Bounds.normalize(
+                                  [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']], 
+                                  [suggested_bounds.attributes['north'], suggested_bounds.attributes['east']])
+        end
+        
         res.success=true
         
         return res        
@@ -458,12 +518,12 @@ module Geokit
     class GeoPluginGeocoder < Geocoder
       private
       
-      def self.do_geocode(ip)
+      def self.do_geocode(ip, options = {})
         return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
         response = self.call_geocoder_service("http://www.geoplugin.net/xml.gp?ip=#{ip}")
         return response.is_a?(Net::HTTPSuccess) ? parse_xml(response.body) : GeoLoc.new
       rescue
-        logger.error "Caught an error during GeloPluginGeocoder geocoding call: "+$!
+        logger.error "Caught an error during GeoPluginGeocoder geocoding call: "+$!
         return GeoLoc.new
       end
 
@@ -476,7 +536,7 @@ module Geokit
         geo.country_code = xml.elements['//geoplugin_countryCode'].text
         geo.lat = xml.elements['//geoplugin_latitude'].text.to_f
         geo.lng = xml.elements['//geoplugin_longitude'].text.to_f
-        geo.success = !geo.city.empty?
+        geo.success = !!geo.city && !geo.city.empty?
         return geo
       end
     end
@@ -491,8 +551,8 @@ module Geokit
       # Given an IP address, returns a GeoLoc instance which contains latitude,
       # longitude, city, and country code.  Sets the success attribute to false if the ip 
       # parameter does not match an ip address.  
-      def self.do_geocode(ip)
-        return Geoloc.new if '0.0.0.0' == ip
+      def self.do_geocode(ip, options = {})
+        return GeoLoc.new if '0.0.0.0' == ip
         return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
         url = "http://api.hostip.info/get_html.php?ip=#{ip}&position=true"
         response = self.call_geocoder_service(url)
@@ -529,7 +589,8 @@ module Geokit
     # -------------------------------------------------------------------------------------------    
     
     # Provides methods to geocode with a variety of geocoding service providers, plus failover
-    # among providers in the order you configure.
+    # among providers in the order you configure. When 2nd parameter is set 'true', perform
+    # ip location lookup with 'address' as the ip address.
     # 
     # Goal:
     # - homogenize the results of multiple geocoders
@@ -537,20 +598,23 @@ module Geokit
     # Limitations:
     # - currently only provides the first result. Sometimes geocoders will return multiple results.
     # - currently discards the "accuracy" component of the geocoding calls
-    class MultiGeocoder < Geocoder 
-      private
+    class MultiGeocoder < Geocoder       
 
+      private
       # This method will call one or more geocoders in the order specified in the 
       # configuration until one of the geocoders work.
       # 
       # The failover approach is crucial for production-grade apps, but is rarely used.
       # 98% of your geocoding calls will be successful with the first call  
-      def self.do_geocode(address)
-        Geokit::Geocoders::provider_order.each do |provider|
+      def self.do_geocode(address, options = {})
+        geocode_ip = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.match(address)
+        provider_order = geocode_ip ? Geokit::Geocoders::ip_provider_order : Geokit::Geocoders::provider_order
+        
+        provider_order.each do |provider|
           begin
-            klass = Geokit::Geocoders.const_get "#{provider.to_s.capitalize}Geocoder"
-            res = klass.send :geocode, address
-            return res if res.success
+            klass = Geokit::Geocoders.const_get "#{Geokit::Inflector::camelize(provider.to_s)}Geocoder"
+            res = klass.send :geocode, address, options
+            return res if res.success?
           rescue
             logger.error("Something has gone very wrong during geocoding, OR you have configured an invalid class name in Geokit::Geocoders::provider_order. Address: #{address}. Provider: #{provider}")
           end
@@ -558,6 +622,23 @@ module Geokit
         # If we get here, we failed completely.
         GeoLoc.new
       end
+      
+      # This method will call one or more geocoders in the order specified in the 
+      # configuration until one of the geocoders work, only this time it's going
+      # to try to reverse geocode a geographical point.
+      def self.do_reverse_geocode(latlng)
+        Geokit::Geocoders::provider_order.each do |provider|
+          begin
+            klass = Geokit::Geocoders.const_get "#{Geokit::Inflector::camelize(provider.to_s)}Geocoder"
+            res = klass.send :reverse_geocode, latlng
+            return res if res.success?
+          rescue
+            logger.error("Something has gone very wrong during reverse geocoding, OR you have configured an invalid class name in Geokit::Geocoders::provider_order. LatLng: #{latlng}. Provider: #{provider}")
+          end
+        end
+        # If we get here, we failed completely.
+        GeoLoc.new
+      end
     end   
   end
 end