keeguon-geokit 1.6.6

data/README.markdown

@@ -0,0 +1,273 @@
+## GEOKIT GEM DESCRIPTION
+
+The Geokit gem provides:
+
+ * Distance calculations between two points on the earth. Calculate the distance in miles, kilometers, or nautical miles, with all the trigonometry abstracted away by GeoKit.
+ * Geocoding from multiple providers. It supports Google, Yahoo, Geocoder.us, and Geocoder.ca geocoders, and others. It provides a uniform response structure from all of them. 
+   It also provides a fail-over mechanism, in case your input fails to geocode in one service.
+ * Rectangular bounds calculations: is a point within a given rectangular bounds?
+ * Heading and midpoint calculations
+
+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
+
+    sudo gem install geokit
+
+## QUICK START
+
+		irb> require 'rubygems'
+		irb> require 'geokit'
+		irb> a=Geokit::Geocoders::YahooGeocoder.geocode '140 Market St, San Francisco, CA'
+		irb> a.ll
+		 => 37.79363,-122.396116
+		irb> b=Geokit::Geocoders::YahooGeocoder.geocode '789 Geary St, San Francisco, CA'
+		irb> b.ll
+		 => 37.786217,-122.41619
+		irb> a.distance_to(b)
+		 => 1.21120007413626
+		irb> a.heading_to(b)
+		=> 244.959832435678
+		irb(main):006:0> c=a.midpoint_to(b)      # what's halfway from a to b?
+		irb> c.ll
+		=> "37.7899239257175,-122.406153503469"
+		irb(main):008:0> d=c.endpoint(90,10)     # what's 10 miles to the east of c?
+		irb> d.ll
+		=> "37.7897825005142,-122.223214776155"
+
+FYI, that `.ll` method means "latitude longitude".
+
+See the RDOC more more ... there are also operations on rectangular bounds (e.g., determining if a point is within bounds, find the center, etc).
+
+## CONFIGURATION
+
+If you're using this gem by itself, here are the configuration options:
+
+		# These defaults are used in Geokit::Mappable.distance_to and in acts_as_mappable
+		Geokit::default_units = :miles
+		Geokit::default_formula = :sphere
+		
+		# This is the timeout value in seconds to be used for calls to the geocoder web
+		# services.  For no timeout at all, comment out the setting.  The timeout unit
+		# is in seconds. 
+		Geokit::Geocoders::request_timeout = 3
+		
+		# These settings are used if web service calls must be routed through a proxy.
+		# These setting can be nil if not needed, otherwise, addr and port must be 
+		# filled in at a minimum.  If the proxy requires authentication, the username
+		# and password can be provided as well.
+		Geokit::Geocoders::proxy_addr = nil
+		Geokit::Geocoders::proxy_port = nil
+		Geokit::Geocoders::proxy_user = nil
+		Geokit::Geocoders::proxy_pass = nil
+		
+		# This is your yahoo application key for the Yahoo Geocoder.
+		# See http://developer.yahoo.com/faq/index.html#appid
+		# and http://developer.yahoo.com/maps/rest/V1/geocode.html
+		Geokit::Geocoders::yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
+		    
+		# This is your Google Maps geocoder key. 
+		# 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 
+		# usage tied to an account, the value should be set to username:password.
+		# See http://geocoder.us
+		# and http://geocoder.us/user/signup
+		Geokit::Geocoders::geocoder_us = false 
+		
+		# This is your authorization key for geocoder.ca.
+		# To use the free service, the value can be set to nil or false.  For 
+		# usage tied to an account, set the value to the key obtained from
+		# Geocoder.ca.
+		# See http://geocoder.ca
+		# 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.
+		# Be aware that there are Terms of Use restrictions on how you can use the 
+		# 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`.
+
+## SUPPORTED GEOCODERS
+
+### "regular" address geocoders 
+* Yahoo Geocoder - requires an API key.
+* Geocoder.us - may require authentication if performing more than the free request limit.
+* Geocoder.ca - for Canada; may require authentication as well.
+* Geonames - a free geocoder
+
+### address geocoders that also provide reverse geocoding 
+* 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::Geocoders::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::Geocoders::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::Geocoders::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::Geocoders::GoogleGeocoder.geocode('Los Angeles').suggested_bounds
+		irb> res = Geokit::Geocoders::GoogleGeocoder.geocode('Winnetka', :bias => la_bounds)
+		irb> res.full_address
+		=> "Winnetka, California, USA"
+
+
+### The Multigeocoder
+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. 
+Geoloc can capture multiple results through its "all" method. Currently only the Google geocoder 
+supports multiple results:
+
+		irb> geo=Geokit::Geocoders::GoogleGeocoder.geocode("900 Sycamore Drive")
+		irb> geo.full_address
+		=> "900 Sycamore Dr, Arkadelphia, AR 71923, USA"
+		irb> geo.all.size
+		irb> geo.all.each { |e| puts e.full_address }
+		900 Sycamore Dr, Arkadelphia, AR 71923, USA
+		900 Sycamore Dr, Burkburnett, TX 76354, USA
+		900 Sycamore Dr, TN 38361, USA
+		.... 
+
+geo.all is just an array of additional Geolocs, so do what you want with it. If you call .all on a 
+geoloc that doesn't have any additional results, you will get  an array of one.
+
+
+## NOTES ON WHAT'S WHERE
+
+mappable.rb contains the Mappable module, which provides basic
+distance calculation methods, i.e., calculating the distance
+between two points. 
+
+mappable.rb also contains LatLng, GeoLoc, and Bounds.
+LatLng is a simple container for latitude and longitude, but 
+it's made more powerful by mixing in the above-mentioned Mappable
+module -- therefore, you can calculate easily the distance between two
+LatLng ojbects with `distance = first.distance_to(other)`
+
+GeoLoc (also in mappable.rb) represents an address or location which
+has been geocoded. You can get the city, zipcode, street address, etc.
+from a GeoLoc object. GeoLoc extends LatLng, so you also get lat/lng
+AND the Mappable modeule goodness for free.
+
+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 
+
+## LICENSE
+
+(The MIT License)
+
+Copyright (c) 2007-2009 Andre Lewis and Bill Eisenhauer
+
+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.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end

data/lib/geokit.rb

@@ -0,0 +1,29 @@
+module Geokit
+  # These defaults are used in Geokit::Mappable.distance_to and in acts_as_mappable
+  @@default_units   = :miles
+  @@default_formula = :sphere
+
+  [:default_units, :default_formula].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
+      end
+    EOS
+  end
+end
+
+path = File.expand_path(File.dirname(__FILE__))
+$:.unshift path unless $:.include?(path)
+require 'geokit/geocoders'
+require 'geokit/mappable'
+
+# make old-style module name "GeoKit" equivalent to new-style "Geokit"
+GeoKit=Geokit

data/lib/geokit/geocoders.rb

@@ -0,0 +1,930 @@
+require 'net/http'
+require 'ipaddr'
+require 'rexml/document'
+require 'yaml'
+require 'timeout'
+require 'logger'
+
+require 'multi_json'
+
+module Geokit
+
+  class TooManyQueriesError < StandardError; end
+
+  module Inflector
+
+    extend self
+
+    def titleize(word)
+      humanize(underscore(word)).gsub(/\b([a-z])/u) { $1.capitalize }
+    end
+
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/u,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/u,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    def humanize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    end
+
+    def snake_case(s)
+      return s.downcase if s =~ /^[A-Z]+$/u
+      s.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/u, '_\&') =~ /_*(.*)/
+        return $+.downcase
+
+    end
+
+    def url_escape(s)
+    s.gsub(/([^ a-zA-Z0-9_.-]+)/nu) do
+      '%' + $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:
+  #
+  # ### "regular" address geocoders
+  # * Yahoo Geocoder - requires an API key.
+  # * Geocoder.us - may require authentication if performing more than the free request limit.
+  # * Geocoder.ca - for Canada; may require authentication as well.
+  # * Geonames - a free geocoder
+  #
+  # ### address geocoders that also provide reverse geocoding
+  # * Google Geocoder - requires an API key.
+  #
+  # ### IP address geocoders
+  # * IP Geocoder - geocodes an IP address using hostip.info's web service.
+  # * Geoplugin.net -- another IP address geocoder
+  #
+  # ### The Multigeocoder
+  # * Multi Geocoder - provides failover for the physical location geocoders.
+  #
+  # Some of these geocoders require configuration. You don't have to provide it here. See the README.
+  module Geocoders
+    @@proxy_addr = nil
+    @@proxy_port = nil
+    @@proxy_user = nil
+    @@proxy_pass = nil
+    @@request_timeout = nil
+    @@yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
+    @@google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
+    @@geocoder_us = false
+    @@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
+
+    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
+      end
+    end
+
+    __define_accessors
+
+    # Error which is thrown in the event a geocoding error occurs.
+    class GeocodeError < StandardError; end
+
+    # -------------------------------------------------------------------------------------------
+    # Geocoder Base class -- every geocoder should inherit from this
+    # -------------------------------------------------------------------------------------------
+
+    # The Geocoder base class which defines the interface to be used by all
+    # other geocoders.
+    class Geocoder
+      # 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, 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
+      end
+
+      # Call the geocoder service using the timeout if configured.
+      def self.call_geocoder_service(url)
+        Timeout::timeout(Geokit::Geocoders::request_timeout) { return self.do_get(url) } if Geokit::Geocoders::request_timeout
+        return self.do_get(url)
+      rescue TimeoutError
+        return nil
+      end
+
+      # Not all geocoders can do reverse geocoding. So, unless the subclass explicitly overrides this method,
+      # a call to reverse_geocode will return an empty GeoLoc. If you happen to be using MultiGeocoder,
+      # this will cause it to failover to the next geocoder, which will hopefully be one which supports reverse geocoding.
+      def self.do_reverse_geocode(latlng)
+        return GeoLoc.new
+      end
+
+      protected
+
+      def self.logger()
+        Geokit::Geocoders::logger
+      end
+
+      private
+
+      # Wraps the geocoder call around a proxy if necessary.
+      def self.do_get(url)
+        uri = URI.parse(url)
+        req = Net::HTTP::Get.new(url)
+        req.basic_auth(uri.user, uri.password) if uri.userinfo
+        res = Net::HTTP::Proxy(GeoKit::Geocoders::proxy_addr,
+                GeoKit::Geocoders::proxy_port,
+                GeoKit::Geocoders::proxy_user,
+                GeoKit::Geocoders::proxy_pass).start(uri.host, uri.port) { |http| http.get(uri.path + "?" + uri.query) }
+        return res
+      end
+
+      # Adds subclass' geocode method making it conveniently available through
+      # the base class.
+      def self.inherited(clazz)
+        class_name = clazz.name.split('::').last
+        src = <<-END_SRC
+          def self.#{Geokit::Inflector.underscore(class_name)}(address, options = {})
+            #{class_name}.geocode(address, options)
+          end
+        END_SRC
+        class_eval(src)
+      end
+    end
+
+    # -------------------------------------------------------------------------------------------
+    # "Regular" Address geocoders
+    # -------------------------------------------------------------------------------------------
+
+    # Geocoder CA geocoder implementation.  Requires the Geokit::Geocoders::GEOCODER_CA variable to
+    # contain true or false based upon whether authentication is to occur.  Conforms to the
+    # interface set by the Geocoder class.
+    #
+    # Returns a response like:
+    # <?xml version="1.0" encoding="UTF-8" ?>
+    # <geodata>
+    #   <latt>49.243086</latt>
+    #   <longt>-123.153684</longt>
+    # </geodata>
+    class CaGeocoder < Geocoder
+
+      private
+
+      # Template method which does the geocode lookup.
+      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)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        xml = res.body
+        logger.debug "Geocoder.ca geocoding. Address: #{address}. Result: #{xml}"
+        # Parse the document.
+        doc = REXML::Document.new(xml)
+        address.lat = doc.elements['//latt'].text
+        address.lng = doc.elements['//longt'].text
+        address.success = true
+        return address
+      rescue
+        logger.error "Caught an error during Geocoder.ca geocoding call: "+$!
+        return GeoLoc.new
+      end
+
+      # Formats the request in the format acceptable by the CA geocoder.
+      def self.construct_request(location)
+        url = ""
+        url += add_ampersand(url) + "stno=#{location.street_number}" if location.street_address
+        url += add_ampersand(url) + "addresst=#{Geokit::Inflector::url_escape(location.street_name)}" if location.street_address
+        url += add_ampersand(url) + "city=#{Geokit::Inflector::url_escape(location.city)}" if location.city
+        url += add_ampersand(url) + "prov=#{location.state}" if location.state
+        url += add_ampersand(url) + "postal=#{location.zip}" if location.zip
+        url += add_ampersand(url) + "auth=#{Geokit::Geocoders::geocoder_ca}" if Geokit::Geocoders::geocoder_ca
+        url += add_ampersand(url) + "geoit=xml"
+        'http://geocoder.ca/?' + url
+      end
+
+      def self.add_ampersand(url)
+        url && url.length > 0 ? "&" : ""
+      end
+    end
+
+    # Geocoder Us geocoder implementation.  Requires the Geokit::Geocoders::GEOCODER_US variable to
+    # contain true or false based upon whether authentication is to occur.  Conforms to the
+    # interface set by the Geocoder class.
+    class UsGeocoder < Geocoder
+
+      private
+      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)}"
+        url = if GeoKit::Geocoders::geocoder_us
+          "http://#{GeoKit::Geocoders::geocoder_us}@geocoder.us/member/service/csv/geocode"
+        else
+          "http://geocoder.us/service/csv/geocode"
+        end
+
+        url = "#{url}?#{query}"
+        res = self.call_geocoder_service(url)
+
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        data = res.body
+        logger.debug "Geocoder.us geocoding. Address: #{address}. Result: #{data}"
+        array = data.chomp.split(',')
+
+        if array.length == 5
+          res=GeoLoc.new
+          res.lat,res.lng,res.city,res.state,res.zip=array
+          res.country_code='US'
+          res.success=true
+          return res
+        elsif array.length == 6
+          res=GeoLoc.new
+          res.lat,res.lng,res.street_address,res.city,res.state,res.zip=array
+          res.country_code='US'
+          res.success=true
+          return res
+        else
+          logger.info "geocoder.us was unable to geocode address: "+address
+          return GeoLoc.new
+        end
+        rescue
+          logger.error "Caught an error during geocoder.us geocoding call: "+$!
+          return GeoLoc.new
+
+      end
+    end
+
+    # Yahoo geocoder implementation.  Requires the Geokit::Geocoders::YAHOO variable to
+    # contain a Yahoo API key.  Conforms to the interface set by the Geocoder class.
+    class YahooGeocoder < Geocoder
+
+      private
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address, options = {})
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        url="http://where.yahooapis.com/geocode?flags=J&appid=#{Geokit::Geocoders::yahoo}&q=#{Geokit::Inflector::url_escape(address_str)}"
+        res = self.call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "Yahoo geocoding. Address: #{address}. Result: #{json}"
+        return self.json2GeoLoc(json, address)
+      end
+
+      def self.json2GeoLoc(json, address)
+        results = MultiJson.decode(json)
+
+        if results['ResultSet']['Error'] == 0
+          geoloc = nil
+          results['ResultSet']['Results'].each do |result|
+            extracted_geoloc = extract_geoloc(result)
+            if geoloc.nil?
+              geoloc = extracted_geoloc
+            else
+              geoloc.all.push(extracted_geoloc)
+            end
+          end
+          return geoloc
+        else
+          logger.info "Yahoo was unable to geocode address: " + address
+          return GeoLoc.new
+        end
+      end
+
+      def self.extract_geoloc(result_json)
+        geoloc = GeoLoc.new
+
+        # basic
+        geoloc.lat            = result_json['latitude']
+        geoloc.lng            = result_json['longitude']
+        geoloc.country_code   = result_json['countrycode']
+        geoloc.provider       = 'yahoo'
+
+        # extended
+        geoloc.street_address = result_json['line1'].to_s.empty? ? nil : result_json['line1']
+        geoloc.city           = result_json['city']
+        geoloc.state          = geoloc.is_us? ? result_json['statecode'] : result_json['state']
+        geoloc.zip            = result_json['postal']
+
+        geoloc.precision = case result_json['quality']
+          when 9,10         then 'country'
+          when 19..30       then 'state'
+          when 39,40        then 'city'
+          when 49,50        then 'neighborhood'
+          when 59,60,64     then 'zip'
+          when 74,75        then 'zip+4'
+          when 70..72       then 'street'
+          when 80..87       then 'address'
+          when 62,63,90,99  then 'building'
+          else 'unknown'
+        end
+
+        geoloc.accuracy = %w{unknown country state state city zip zip+4 street address building}.index(geoloc.precision)
+        geoloc.success = true
+
+        return geoloc
+      end
+    end
+
+    # Another geocoding web service
+    # http://www.geonames.org
+    class GeonamesGeocoder < Geocoder
+
+      private
+
+      # Template method which does the geocode lookup.
+      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!(/,/, " ")
+        params = "/postalCodeSearch?placename=#{Geokit::Inflector::url_escape(address_str)}&maxRows=10"
+
+        if(GeoKit::Geocoders::geonames)
+          url = "http://ws.geonames.net#{params}&username=#{GeoKit::Geocoders::geonames}"
+        else
+          url = "http://ws.geonames.org#{params}"
+        end
+
+        res = self.call_geocoder_service(url)
+
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+
+        xml=res.body
+        logger.debug "Geonames geocoding. Address: #{address}. Result: #{xml}"
+        doc=REXML::Document.new(xml)
+
+        if(doc.elements['//geonames/totalResultsCount'].text.to_i > 0)
+          res=GeoLoc.new
+
+          # only take the first result
+          res.lat=doc.elements['//code/lat'].text if doc.elements['//code/lat']
+          res.lng=doc.elements['//code/lng'].text if doc.elements['//code/lng']
+          res.country_code=doc.elements['//code/countryCode'].text if doc.elements['//code/countryCode']
+          res.provider='genomes'
+          res.city=doc.elements['//code/name'].text if doc.elements['//code/name']
+          res.state=doc.elements['//code/adminName1'].text if doc.elements['//code/adminName1']
+          res.zip=doc.elements['//code/postalcode'].text if doc.elements['//code/postalcode']
+          res.success=true
+          return res
+        else
+          logger.info "Geonames was unable to geocode address: "+address
+          return GeoLoc.new
+        end
+
+        rescue
+          logger.error "Caught an error during Geonames geocoding call: "+$!
+      end
+    end
+
+    # -------------------------------------------------------------------------------------------
+    # Address geocoders that also provide reverse geocoding
+    # -------------------------------------------------------------------------------------------
+
+    # Google geocoder implementation.  Requires the Geokit::Geocoders::GOOGLE variable to
+    # contain a Google API key.  Conforms to the interface set by the Geocoder class.
+    class GoogleGeocoder < Geocoder
+
+      private
+
+      # Template method which does the reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng)
+        latlng=LatLng.normalize(latlng)
+        res = self.call_geocoder_service("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(latlng.ll)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8")
+        #        res = Net::HTTP.get_response(URI.parse("http://maps.google.com/maps/geo?ll=#{Geokit::Inflector::url_escape(address_str)}&output=xml&key=#{Geokit::Geocoders::google}&oe=utf-8"))
+        return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
+        xml = res.body
+        logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{xml}"
+        return self.xml2GeoLoc(xml)
+      end
+
+      # Template method which does the geocode lookup.
+      #
+      # 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#{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, address)
+      end
+
+      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'
+          geoloc = nil
+          # 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
+            if geoloc.nil?
+              # 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
+              # geolocs onto "geoloc.all"
+              geoloc.all.push(extracted_geoloc)
+            end
+          end
+          return geoloc
+        elsif doc.elements['//kml/Response/Status/code'].text == '620'
+           raise Geokit::TooManyQueriesError
+        else
+          logger.info "Google was unable to geocode address: "+address
+          return GeoLoc.new
+        end
+
+      rescue Geokit::TooManyQueriesError
+        # re-raise because of other rescue
+        raise Geokit::TooManyQueriesError, "Google returned a 620 status, too many queries. The given key has gone over the requests limit in the 24 hour period or has submitted too many requests in too short a period of time. If you're sending multiple requests in parallel or in a tight loop, use a timer or pause in your code to make sure you don't send the requests too quickly."
+      rescue
+        logger.error "Caught an error during Google geocoding call: "+$!
+        return GeoLoc.new
+      end
+
+      # extracts a single geoloc from a //placemark element in the google results xml
+      def self.extract_placemark(doc)
+        res = GeoLoc.new
+        coordinates=doc.elements['.//coordinates'].text.to_s.split(',')
+
+        #basics
+        res.lat=coordinates[1]
+        res.lng=coordinates[0]
+        res.country_code=doc.elements['.//CountryNameCode'].text if doc.elements['.//CountryNameCode']
+        res.provider='google'
+
+        #extended -- false if not not available
+        res.city = doc.elements['.//LocalityName'].text if doc.elements['.//LocalityName']
+        res.state = doc.elements['.//AdministrativeAreaName'].text if doc.elements['.//AdministrativeAreaName']
+        res.province = doc.elements['.//SubAdministrativeAreaName'].text if doc.elements['.//SubAdministrativeAreaName']
+        res.full_address = doc.elements['.//address'].text if doc.elements['.//address'] # google provides it
+        res.zip = doc.elements['.//PostalCodeNumber'].text if doc.elements['.//PostalCodeNumber']
+        res.street_address = doc.elements['.//ThoroughfareName'].text if doc.elements['.//ThoroughfareName']
+        res.country = doc.elements['.//CountryName'].text if doc.elements['.//CountryName']
+        res.district = doc.elements['.//DependentLocalityName'].text if doc.elements['.//DependentLocalityName']
+        # 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"]']
+        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
+      end
+    end
+
+    class GoogleGeocoder3 < Geocoder
+
+      private
+      # Template method which does the reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng)
+        latlng=LatLng.normalize(latlng)
+        res = self.call_geocoder_service("http://maps.google.com/maps/api/geocode/json?sensor=false&latlng=#{Geokit::Inflector::url_escape(latlng.ll)}")
+        return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
+        json = res.body
+        logger.debug "Google reverse-geocoding. LL: #{latlng}. Result: #{json}"
+        return self.json2GeoLoc(json)
+      end
+
+      # Template method which does the geocode lookup.
+      #
+      # 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/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(address_str)}#{bias_str}")
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+
+        json = res.body
+        logger.debug "Google geocoding. Address: #{address}. Result: #{CGI.escape(json)}"
+
+        return self.json2GeoLoc(json, address)
+      end
+
+      def self.construct_bias_string_from_options(bias)
+        if bias.is_a?(String) or bias.is_a?(Symbol)
+          # country code biasing
+          "&region=#{bias.to_s.downcase}"
+        elsif bias.is_a?(Bounds)
+          # viewport biasing
+          Geokit::Inflector::url_escape("&bounds=#{bias.sw.to_s}|#{bias.ne.to_s}")
+        end
+      end
+
+      def self.json2GeoLoc(json, address="")
+        ret=nil
+        results = MultiJson.decode(json)
+
+        if results['status'] == 'OVER_QUERY_LIMIT'
+          raise Geokit::TooManyQueriesError
+        end
+        if results['status'] == 'ZERO_RESULTS'
+          return GeoLoc.new
+        end
+        # this should probably be smarter.
+        if !results['status'] == 'OK'
+          raise Geokit::Geocoders::GeocodeError
+        end
+        # location_type stores additional data about the specified location.
+        # The following values are currently supported:
+        # "ROOFTOP" indicates that the returned result is a precise geocode
+        # for which we have location information accurate down to street
+        # address precision.
+        # "RANGE_INTERPOLATED" indicates that the returned result reflects an
+        # approximation (usually on a road) interpolated between two precise
+        # points (such as intersections). Interpolated results are generally
+        # returned when rooftop geocodes are unavailable for a street address.
+        # "GEOMETRIC_CENTER" indicates that the returned result is the
+        # geometric center of a result such as a polyline (for example, a
+        # street) or polygon (region).
+        # "APPROXIMATE" indicates that the returned result is approximate
+
+        # these do not map well. Perhaps we should guess better based on size
+        # of bounding box where it exists? Does it really matter?
+        accuracy = {
+          "ROOFTOP" => 9,
+          "RANGE_INTERPOLATED" => 8,
+          "GEOMETRIC_CENTER" => 5,
+          "APPROXIMATE" => 4
+        }
+
+        @unsorted = []
+
+        results['results'].each do |addr|
+          res = GeoLoc.new
+          res.provider = 'google3'
+          res.success = true
+          res.full_address = addr['formatted_address']
+
+          addr['address_components'].each do |comp|
+            case
+            when comp['types'].include?("subpremise")
+              res.sub_premise = comp['short_name']
+            when comp['types'].include?("street_number")
+              res.street_number = comp['short_name']
+            when comp['types'].include?("route")
+              res.street_name = comp['long_name']
+            when comp['types'].include?("locality")
+              res.city = comp['long_name']
+            when comp['types'].include?("administrative_area_level_1")
+              res.state = comp['short_name']
+              res.province = comp['short_name']
+            when comp['types'].include?("postal_code")
+              res.zip = comp['long_name']
+            when comp['types'].include?("country")
+              res.country_code = comp['short_name']
+              res.country = comp['long_name']
+            when comp['types'].include?("administrative_area_level_2")
+              res.district = comp['long_name']
+            end
+          end
+          if res.street_name
+            res.street_address=[res.street_number,res.street_name].join(' ').strip
+          end
+          res.accuracy = accuracy[addr['geometry']['location_type']]
+          res.precision=%w{unknown country state state city zip zip+4 street address building}[res.accuracy]
+          # try a few overrides where we can
+          if res.sub_premise
+            res.accuracy = 9
+            res.precision = 'building'
+          end
+          if res.street_name && res.precision=='city'
+            res.precision = 'street'
+            res.accuracy = 7
+          end
+
+          res.lat=addr['geometry']['location']['lat'].to_f
+          res.lng=addr['geometry']['location']['lng'].to_f
+
+          ne=Geokit::LatLng.new(
+            addr['geometry']['viewport']['northeast']['lat'].to_f,
+            addr['geometry']['viewport']['northeast']['lng'].to_f
+            )
+          sw=Geokit::LatLng.new(
+            addr['geometry']['viewport']['southwest']['lat'].to_f,
+            addr['geometry']['viewport']['southwest']['lng'].to_f
+          )
+          res.suggested_bounds = Geokit::Bounds.new(sw,ne)
+
+          @unsorted << res
+        end
+
+        all = @unsorted.sort_by { |a| a.accuracy }.reverse
+        encoded = all.first
+        encoded.all = all
+        return encoded
+      end
+    end
+
+    class FCCGeocoder < Geocoder
+
+       private
+       # Template method which does the reverse-geocode lookup.
+       def self.do_reverse_geocode(latlng)
+         latlng=LatLng.normalize(latlng)
+         res = self.call_geocoder_service("http://data.fcc.gov/api/block/find?format=json&latitude=#{Geokit::Inflector::url_escape(latlng.lat.to_s)}&longitude=#{Geokit::Inflector::url_escape(latlng.lng.to_s)}")
+         return GeoLoc.new unless (res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPOK))
+         json = res.body
+         logger.debug "FCC reverse-geocoding. LL: #{latlng}. Result: #{json}"
+         return self.json2GeoLoc(json)
+       end
+
+       # Template method which does the geocode lookup.
+       #
+       # ==== EXAMPLES
+       # ll=GeoKit::LatLng.new(40, -85)
+       # Geokit::Geocoders::FCCGeocoder.geocode(ll) #
+
+       # JSON result looks like this
+       # => {"County"=>{"name"=>"Wayne", "FIPS"=>"18177"},
+       # "Block"=>{"FIPS"=>"181770103002004"},
+       # "executionTime"=>"0.099",
+       # "State"=>{"name"=>"Indiana", "code"=>"IN", "FIPS"=>"18"},
+       # "status"=>"OK"}
+
+       def self.json2GeoLoc(json, address="")
+         ret = nil
+         results = MultiJson.decode(json)
+
+         if results.has_key?('Err') and results['Err']["msg"] == 'There are no results for this location'
+           return GeoLoc.new
+         end
+         # this should probably be smarter.
+         if !results['status'] == 'OK'
+           raise Geokit::Geocoders::GeocodeError
+         end
+
+         res = GeoLoc.new
+         res.provider      = 'fcc'
+         res.success       = true
+         res.precision     = 'block'
+         res.country_code  = 'US'
+         res.district      = results['County']['name']
+         res.district_fips = results['County']['FIPS']
+         res.state         = results['State']['code']
+         res.state_fips    = results['State']['FIPS']
+         res.block_fips    = results['Block']['FIPS']
+
+         res
+       end
+     end
+    # -------------------------------------------------------------------------------------------
+    # IP Geocoders
+    # -------------------------------------------------------------------------------------------
+
+    # Provides geocoding based upon an IP address.  The underlying web service is geoplugin.net
+    class GeoPluginGeocoder < Geocoder
+      private
+
+      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 GeoPluginGeocoder geocoding call: "+$!
+        return GeoLoc.new
+      end
+
+      def self.parse_xml(xml)
+        xml = REXML::Document.new(xml)
+        geo = GeoLoc.new
+        geo.provider='geoPlugin'
+        geo.city = xml.elements['//geoplugin_city'].text
+        geo.state = xml.elements['//geoplugin_region'].text
+        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 && !geo.city.empty?
+        return geo
+      end
+    end
+
+    # Provides geocoding based upon an IP address.  The underlying web service is a hostip.info
+    # which sources their data through a combination of publicly available information as well
+    # as community contributions.
+    class IpGeocoder < Geocoder
+
+      # A number of non-routable IP ranges.
+      #
+      # --
+      # Sources for these:
+      #   RFC 3330: Special-Use IPv4 Addresses
+      #   The bogon list: http://www.cymru.com/Documents/bogon-list.html
+
+      NON_ROUTABLE_IP_RANGES = [
+        IPAddr.new('0.0.0.0/8'),      # "This" Network
+        IPAddr.new('10.0.0.0/8'),     # Private-Use Networks
+        IPAddr.new('14.0.0.0/8'),     # Public-Data Networks
+        IPAddr.new('127.0.0.0/8'),    # Loopback
+        IPAddr.new('169.254.0.0/16'), # Link local
+        IPAddr.new('172.16.0.0/12'),  # Private-Use Networks
+        IPAddr.new('192.0.2.0/24'),   # Test-Net
+        IPAddr.new('192.168.0.0/16'), # Private-Use Networks
+        IPAddr.new('198.18.0.0/15'),  # Network Interconnect Device Benchmark Testing
+        IPAddr.new('224.0.0.0/4'),    # Multicast
+        IPAddr.new('240.0.0.0/4')     # Reserved for future use
+      ].freeze
+
+      private
+
+      # 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, options = {})
+        return GeoLoc.new unless /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/.match(ip)
+        return GeoLoc.new if self.private_ip_address?(ip)
+        url = "http://api.hostip.info/get_html.php?ip=#{ip}&position=true"
+        response = self.call_geocoder_service(url)
+        response.is_a?(Net::HTTPSuccess) ? parse_body(response.body) : GeoLoc.new
+      rescue
+        logger.error "Caught an error during HostIp geocoding call: "+$!
+        return GeoLoc.new
+      end
+
+      # Converts the body to YAML since its in the form of:
+      #
+      # Country: UNITED STATES (US)
+      # City: Sugar Grove, IL
+      # Latitude: 41.7696
+      # Longitude: -88.4588
+      #
+      # then instantiates a GeoLoc instance to populate with location data.
+      def self.parse_body(body) # :nodoc:
+        yaml = YAML.load(body)
+        res = GeoLoc.new
+        res.provider = 'hostip'
+        res.city, res.state = yaml['City'].split(', ')
+        country, res.country_code = yaml['Country'].split(' (')
+        res.lat = yaml['Latitude']
+        res.lng = yaml['Longitude']
+        res.country_code.chop!
+        res.success = !(res.city =~ /\(.+\)/)
+        res
+      end
+
+      # Checks whether the IP address belongs to a private address range.
+      #
+      # This function is used to reduce the number of useless queries made to
+      # the geocoding service. Such queries can occur frequently during
+      # integration tests.
+      def self.private_ip_address?(ip)
+        return NON_ROUTABLE_IP_RANGES.any? { |range| range.include?(ip) }
+      end
+    end
+
+    # -------------------------------------------------------------------------------------------
+    # The Multi Geocoder
+    # -------------------------------------------------------------------------------------------
+
+    # Provides methods to geocode with a variety of geocoding service providers, plus failover
+    # 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
+    #
+    # 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
+      # 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, 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 "#{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
+        end
+        # 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