geokit 1.5.0 → 1.6.0

data/README.markdown

@@ -54,7 +54,7 @@ If you're using this gem by itself, here are the configuration options:
 		# 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::timeout = 3
+		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 
@@ -142,26 +142,26 @@ The Google Geocoder sports a number of useful tricks that elevate it a little bi
 
 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 = 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::Geocoder::GoogleGeocoder.geocode('Syracuse', :bias => 'it')
+		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::Geocoder::GoogleGeocoder.geocode('Winnetka')
+		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::Geocoder::GoogleGeocoder.geocode('Los Angeles').suggested_bounds
-		irb> res = Geokit::Geocoder::GoogleGeocoder.geocode('Winnetka', :bias => la_bounds)
+		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"
 

data/Rakefile

@@ -1,9 +1,11 @@
 # -*- ruby -*-
 
+require "rake/gempackagetask"
 require 'rubygems'
 require 'hoe'
 require './lib/geokit.rb'
 
+
 # undefined method `empty?' for nil:NilClass
 # /Library/Ruby/Site/1.8/rubygems/specification.rb:886:in `validate' 
 class NilClass

data/geokit.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{geokit}
-  s.version = "1.5.0"
+  s.version = "1.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andre Lewis and Bill Eisenhauer"]
@@ -10,7 +10,12 @@ Gem::Specification.new do |s|
   s.description = %q{Geokit Gem}
   s.email = ["andre@earthcode.com / bill_eisenhauer@yahoo.com"]
   s.extra_rdoc_files = ["Manifest.txt", "README.markdown"]
-  s.files = ["Manifest.txt", "README.markdown", "Rakefile", "lib/geokit/geocoders.rb", "lib/geokit.rb", "lib/geokit/mappable.rb", "test/test_base_geocoder.rb", "test/test_bounds.rb", "test/test_ca_geocoder.rb", "test/test_geoloc.rb", "test/test_google_geocoder.rb", "test/test_latlng.rb", "test/test_multi_geocoder.rb", "test/test_us_geocoder.rb", "test/test_yahoo_geocoder.rb"]
+  s.files = ["Manifest.txt", "README.markdown", "Rakefile", "lib/geokit/geocoders.rb", "lib/geokit.rb",
+    "lib/geokit/mappable.rb", "test/test_base_geocoder.rb", "test/test_bounds.rb",
+    "test/test_ca_geocoder.rb", "test/test_geoloc.rb", "test/test_google_geocoder3.rb",
+    "test/test_google_geocoder.rb", "test/test_latlng.rb", "test/test_multi_geocoder.rb",
+    "test/test_us_geocoder.rb", "test/test_yahoo_geocoder.rb"
+  ]
   s.has_rdoc = true
   s.homepage = %q{http://geokit.rubyforge.org}
   s.rdoc_options = ["--main", "README.markdown"]
@@ -18,15 +23,16 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{geokit}
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{none}
-  s.test_files = ["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", 
-  								"test/test_multi_ip_geocoder.rb", "test/test_us_geocoder.rb", "test/test_yahoo_geocoder.rb"]
-
+  s.test_files = [ 
+    "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_geocoder3.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",
+    "test/test_multi_ip_geocoder.rb", "test/test_us_geocoder.rb", "test/test_yahoo_geocoder.rb"
+  ]
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 2
   end
+  s.add_dependency(%q{json_pure})
 end
-
-

data/lib/geokit.rb

@@ -1,5 +1,5 @@
 module Geokit
-  VERSION = '1.5.0'
+  VERSION = '1.6.0'
   # These defaults are used in Geokit::Mappable.distance_to and in acts_as_mappable
   @@default_units = :miles
   @@default_formula = :sphere

data/lib/geokit/geocoders.rb

@@ -1,9 +1,17 @@
 require 'net/http'
+require 'ipaddr'
 require 'rexml/document'
 require 'yaml'
 require 'timeout'
 require 'logger'
 
+# do this just in case 
+begin 
+  ActiveSupport.nil?
+rescue NameError
+  require 'json/pure'
+end
+
 module Geokit
 
   class TooManyQueriesError < StandardError; end
@@ -519,7 +527,220 @@ module Geokit
       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: #{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
+        begin
+          results=::ActiveSupport::JSON.decode(json)
+        rescue NameError => e
+          results=JSON.parse(json)
+        end
+          
+        
+        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
+        }
+        results['results'].sort_by{|a|accuracy[a['geometry']['location_type']]}.reverse.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?("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.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)
+
+          if ret
+            ret.all.push(res)
+          else
+            ret=res
+          end
+        end
+        return ret
+      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
+         begin
+           results=::ActiveSupport::JSON.decode(json)
+         rescue NameError => e
+           results=JSON.parse(json)
+         end
+         
+         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
     # -------------------------------------------------------------------------------------------
@@ -556,14 +777,35 @@ module Geokit
     # 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 if '0.0.0.0' == ip
         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
@@ -592,6 +834,15 @@ module Geokit
         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
     
     # -------------------------------------------------------------------------------------------

data/lib/geokit/mappable.rb

@@ -287,6 +287,8 @@ module Geokit
         return thing
       elsif thing.class.respond_to?(:acts_as_mappable) && thing.class.respond_to?(:distance_column_name)
         return thing.to_lat_lng
+      elsif thing.respond_to? :to_lat_lng
+        return thing.to_lat_lng
       end
       
       raise ArgumentError.new("#{thing} (#{thing.class}) cannot be normalized to a LatLng. We tried interpreting it as an array, string, Mappable, etc., but no dice.")
@@ -342,22 +344,26 @@ module Geokit
 
     # Location attributes.  Full address is a concatenation of all values.  For example:
     # 100 Spear St, San Francisco, CA, 94101, US
-    attr_accessor :street_address, :city, :state, :zip, :country_code, :country, :full_address, :all, :district, :province
+    # Street number and street name are extracted from the street address attribute if they don't exist
+    attr_accessor :street_number,:street_name,:street_address, :city, :state, :zip, :country_code, :country, :full_address, :all, :district, :province
     # Attributes set upon return from geocoding.  Success will be true for successful
     # geocode lookups.  The provider will be set to the name of the providing geocoder.
     # Finally, precision is an indicator of the accuracy of the geocoding.
     attr_accessor :success, :provider, :precision, :suggested_bounds
-    # Street number and street name are extracted from the street address attribute.
-    attr_reader :street_number, :street_name
     # accuracy is set for Yahoo and Google geocoders, it is a numeric value of the 
     # precision. see http://code.google.com/apis/maps/documentation/geocoding/#GeocodingAccuracy
     attr_accessor :accuracy
+    # FCC Attributes
+    attr_accessor :district_fips, :state_fips, :block_fips
+    
 
     # Constructor expects a hash of symbols to correspond with attributes.
     def initialize(h={})
       @all = [self]
       
       @street_address=h[:street_address] 
+      @street_number=nil
+      @street_name=nil
       @city=h[:city] 
       @state=h[:state] 
       @zip=h[:zip] 
@@ -385,21 +391,22 @@ module Geokit
       @full_address ? @full_address : to_geocodeable_s
     end
 
-    # Extracts the street number from the street address if the street address
-    # has a value.
+    # Extracts the street number from the street address where possible.
     def street_number
-      street_address[/(\d*)/] if street_address
+      @street_number ||= street_address[/(\d*)/] if street_address
+      @street_number
     end
 
-    # Returns the street name portion of the street address.
+    # Returns the street name portion of the street address where possible
     def street_name
-       street_address[street_number.length, street_address.length].strip if street_address
+      @street_name||=street_address[street_number.length, street_address.length].strip if street_address
+      @street_name
     end
 
     # gives you all the important fields as key-value pairs
     def hash
       res={}
-      [:success,:lat,:lng,:country_code,:city,:state,:zip,:street_address,:province,:district,:provider,:full_address,:is_us?,:ll,:precision].each { |s| res[s] = self.send(s.to_s) }
+      [:success,:lat,:lng,:country_code,:city,:state,:zip,:street_address,:province,:district,:provider,:full_address,:is_us?,:ll,:precision,:district_fips,:state_fips,:block_fips].each { |s| res[s] = self.send(s.to_s) }
       res
     end
     alias to_hash hash
@@ -411,8 +418,12 @@ module Geokit
 
     # Sets the street address after capitalizing each word within the street address.
     def street_address=(address)
-      @street_address = Geokit::Inflector::titleize(address) if address
-    end
+      if address and not ['google','google3'].include?(self.provider)
+        @street_address = Geokit::Inflector::titleize(address) 
+      else
+        @street_address = address
+      end
+    end  
     
     # Returns a comma-delimited string consisting of the street address, city, state,
     # zip, and country code.  Only includes those attributes that are non-blank.

data/test/test_geoloc.rb

@@ -65,7 +65,7 @@ class GeoLocTest < Test::Unit::TestCase #:nodoc: all
     @loc.zip = '94105'
     @loc.country_code = 'US'
     assert_equal( 
-      "--- !ruby/object:Geokit::GeoLoc \ncity: San Francisco\ncountry_code: US\nfull_address: \nlat: \nlng: \nprecision: unknown\nprovince: \nstate: CA\nstreet_address: \nsuccess: false\nzip: \"94105\"\n", 
+      "--- !ruby/object:Geokit::GeoLoc \ncity: San Francisco\ncountry_code: US\nfull_address: \nlat: \nlng: \nprecision: unknown\nprovince: \nstate: CA\nstreet_address: \nstreet_name: \nstreet_number: \nsuccess: false\nzip: \"94105\"\n", 
       @loc.to_yaml)
   end
   

data/test/test_geoplugin_geocoder.rb

@@ -33,8 +33,8 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     GeoKit::Geocoders::GeoPluginGeocoder.expects(:call_geocoder_service).with(url).returns(success)
     location = GeoKit::Geocoders::GeoPluginGeocoder.geocode('200.150.38.66')
     assert_not_nil location
-    assert_equal -19.916700, location.lat
-    assert_equal -43.933300, location.lng
+    assert_equal(-19.916700, location.lat)
+    assert_equal(-43.933300, location.lng)
     assert_equal "Belo Horizonte", location.city
     assert_equal "Minas Gerais", location.state
     assert_equal "BR", location.country_code

data/test/test_google_geocoder.rb

@@ -186,7 +186,7 @@ class GoogleGeocoderTest < BaseGeocoderTest #:nodoc: all
 
     assert_equal "Plaza de la Puerta del Sol, 28013, Madrid, Spain", res.full_address
     assert_equal "28013", res.zip
-    assert_equal "Plaza De La Puerta Del Sol", res.street_address
+    assert_equal "Plaza de la Puerta del Sol", res.street_address
   end  
   
   def test_country_code_biasing

data/test/test_google_geocoder3.rb

@@ -0,0 +1,536 @@
+require File.join(File.dirname(__FILE__), 'test_base_geocoder')
+
+Geokit::Geocoders::google = 'Google'
+
+class GoogleGeocoder3Test < BaseGeocoderTest #:nodoc: all
+  
+  GOOGLE3_FULL=%q/
+  {
+    "status": "OK",
+    "results": [ {
+      "types": [ "street_address" ],
+      "formatted_address": "100 Spear St, San Francisco, CA 94105, USA",
+      "address_components": [ {
+        "long_name": "100",
+        "short_name": "100",
+        "types": [ "street_number" ]
+      }, {
+        "long_name": "Spear St",
+        "short_name": "Spear St",
+        "types": [ "route" ]
+      }, {
+        "long_name": "San Francisco",
+        "short_name": "San Francisco",
+        "types": [ "locality", "political" ]
+      }, {
+        "long_name": "San Francisco",
+        "short_name": "San Francisco",
+        "types": [ "administrative_area_level_3", "political" ]
+      }, {
+        "long_name": "San Francisco",
+        "short_name": "San Francisco",
+        "types": [ "administrative_area_level_2", "political" ]
+      }, {
+        "long_name": "California",
+        "short_name": "CA",
+        "types": [ "administrative_area_level_1", "political" ]
+      }, {
+        "long_name": "United States",
+        "short_name": "US",
+        "types": [ "country", "political" ]
+      }, {
+        "long_name": "94105",
+        "short_name": "94105",
+        "types": [ "postal_code" ]
+      } ],
+      "geometry": {
+        "location": {
+          "lat": 37.7921509,
+          "lng": -122.3940000
+        },
+        "location_type": "ROOFTOP",
+        "viewport": {
+          "southwest": {
+            "lat": 37.7890033,
+            "lng": -122.3971476
+          },
+          "northeast": {
+            "lat": 37.7952985,
+            "lng": -122.3908524
+          }
+        }
+      }
+    } ]
+  }
+  /.strip
+
+  GOOGLE3_CITY=%q/
+  {
+    "status": "OK",
+    "results": [ {
+      "types": [ "locality", "political" ],
+      "formatted_address": "San Francisco, CA, USA",
+      "address_components": [ {
+        "long_name": "San Francisco",
+        "short_name": "San Francisco",
+        "types": [ "locality", "political" ]
+      }, {
+        "long_name": "San Francisco",
+        "short_name": "San Francisco",
+        "types": [ "administrative_area_level_2", "political" ]
+      }, {
+        "long_name": "California",
+        "short_name": "CA",
+        "types": [ "administrative_area_level_1", "political" ]
+      }, {
+        "long_name": "United States",
+        "short_name": "US",
+        "types": [ "country", "political" ]
+      } ],
+      "geometry": {
+        "location": {
+          "lat": 37.7749295,
+          "lng": -122.4194155
+        },
+        "location_type": "APPROXIMATE",
+        "viewport": {
+          "southwest": {
+            "lat": 37.7043396,
+            "lng": -122.5474749
+          },
+          "northeast": {
+            "lat": 37.8454521,
+            "lng": -122.2913561
+          }
+        },
+        "bounds": {
+          "southwest": {
+            "lat": 37.7034000,
+            "lng": -122.5270000
+          },
+          "northeast": {
+            "lat": 37.8120000,
+            "lng": -122.3482000
+          }
+        }
+      }
+    } ]
+  }
+  /.strip
+  GOOGLE3_MULTI=%q/
+    {
+      "status": "OK",
+      "results": [ {
+        "types": [ "street_address" ],
+        "formatted_address": "Via Sandro Pertini, 8, 20010 Mesero MI, Italy",
+        "address_components": [ {
+          "long_name": "8",
+          "short_name": "8",
+          "types": [ "street_number" ]
+        }, {
+          "long_name": "Via Sandro Pertini",
+          "short_name": "Via Sandro Pertini",
+          "types": [ "route" ]
+        }, {
+          "long_name": "Mesero",
+          "short_name": "Mesero",
+          "types": [ "locality", "political" ]
+        }, {
+          "long_name": "Milan",
+          "short_name": "MI",
+          "types": [ "administrative_area_level_2", "political" ]
+        }, {
+          "long_name": "Lombardy",
+          "short_name": "Lombardy",
+          "types": [ "administrative_area_level_1", "political" ]
+        }, {
+          "long_name": "Italy",
+          "short_name": "IT",
+          "types": [ "country", "political" ]
+        }, {
+          "long_name": "20010",
+          "short_name": "20010",
+          "types": [ "postal_code" ]
+        } ],
+        "geometry": {
+          "location": {
+            "lat": 45.4966218,
+            "lng": 8.8526940
+          },
+          "location_type": "RANGE_INTERPOLATED",
+          "viewport": {
+            "southwest": {
+              "lat": 45.4934754,
+              "lng": 8.8495559
+            },
+            "northeast": {
+              "lat": 45.4997707,
+              "lng": 8.8558512
+            }
+          },
+          "bounds": {
+            "southwest": {
+              "lat": 45.4966218,
+              "lng": 8.8526940
+            },
+            "northeast": {
+              "lat": 45.4966243,
+              "lng": 8.8527131
+            }
+          }
+        },
+        "partial_match": true
+      },
+      {
+         "types": [ "route" ],
+         "formatted_address": "Via Sandro Pertini, 20010 Ossona MI, Italy",
+         "address_components": [ {
+           "long_name": "Via Sandro Pertini",
+           "short_name": "Via Sandro Pertini",
+           "types": [ "route" ]
+         }, {
+           "long_name": "Ossona",
+           "short_name": "Ossona",
+           "types": [ "locality", "political" ]
+         }, {
+           "long_name": "Milan",
+           "short_name": "MI",
+           "types": [ "administrative_area_level_2", "political" ]
+         }, {
+           "long_name": "Lombardy",
+           "short_name": "Lombardy",
+           "types": [ "administrative_area_level_1", "political" ]
+         }, {
+           "long_name": "Italy",
+           "short_name": "IT",
+           "types": [ "country", "political" ]
+         }, {
+           "long_name": "20010",
+           "short_name": "20010",
+           "types": [ "postal_code" ]
+         } ],
+         "geometry": {
+           "location": {
+             "lat": 45.5074444,
+             "lng": 8.9023200
+           },
+           "location_type": "GEOMETRIC_CENTER",
+           "viewport": {
+             "southwest": {
+               "lat": 45.5043320,
+               "lng": 8.8990670
+             },
+             "northeast": {
+               "lat": 45.5106273,
+               "lng": 8.9053622
+             }
+           },
+           "bounds": {
+             "southwest": {
+               "lat": 45.5064427,
+               "lng": 8.9020024
+             },
+             "northeast": {
+               "lat": 45.5085166,
+               "lng": 8.9024268
+             }
+           }
+         }
+       }
+      ]
+    }
+  /.strip
+  GOOGLE3_REVERSE_MADRID=%q/
+  {
+    "status": "OK",
+    "results": [ {
+      "types": [ ],
+      "formatted_address": "Calle de las Carretas, 28013 Madrid, Spain",
+      "address_components": [ {
+        "long_name": "Calle de las Carretas",
+        "short_name": "Calle de las Carretas",
+        "types": [ "route" ]
+      }, {
+        "long_name": "Madrid",
+        "short_name": "Madrid",
+        "types": [ "locality", "political" ]
+      }, {
+        "long_name": "Madrid",
+        "short_name": "M",
+        "types": [ "administrative_area_level_2", "political" ]
+      }, {
+        "long_name": "Madrid",
+        "short_name": "Madrid",
+        "types": [ "administrative_area_level_1", "political" ]
+      }, {
+        "long_name": "Spain",
+        "short_name": "ES",
+        "types": [ "country", "political" ]
+      }, {
+        "long_name": "28013",
+        "short_name": "28013",
+        "types": [ "postal_code" ]
+      } ],
+      "geometry": {
+        "location": {
+          "lat": 40.4166824,
+          "lng": -3.7033411
+        },
+        "location_type": "APPROXIMATE",
+        "viewport": {
+          "southwest": {
+            "lat": 40.4135351,
+            "lng": -3.7064880
+          },
+          "northeast": {
+            "lat": 40.4198303,
+            "lng": -3.7001927
+          }
+        },
+        "bounds": {
+          "southwest": {
+            "lat": 40.4166419,
+            "lng": -3.7033685
+          },
+          "northeast": {
+            "lat": 40.4167235,
+            "lng": -3.7033122
+          }
+        }
+      }
+    } ]
+  }
+  /
+  GOOGLE3_COUNTRY_CODE_BIASED_RESULT=%q/
+  {
+    "status": "OK",
+    "results": [ {
+      "types": [ "administrative_area_level_2", "political" ],
+      "formatted_address": "Syracuse, Italy",
+      "address_components": [ {
+        "long_name": "Syracuse",
+        "short_name": "SR",
+        "types": [ "administrative_area_level_2", "political" ]
+      }, {
+        "long_name": "Sicily",
+        "short_name": "Sicily",
+        "types": [ "administrative_area_level_1", "political" ]
+      }, {
+        "long_name": "Italy",
+        "short_name": "IT",
+        "types": [ "country", "political" ]
+      } ],
+      "geometry": {
+        "location": {
+          "lat": 37.0630218,
+          "lng": 14.9856176
+        },
+        "location_type": "APPROXIMATE",
+        "viewport": {
+          "southwest": {
+            "lat": 36.7775664,
+            "lng": 14.4733800
+          },
+          "northeast": {
+            "lat": 37.3474070,
+            "lng": 15.4978552
+          }
+        },
+        "bounds": {
+          "southwest": {
+            "lat": 36.6441736,
+            "lng": 14.7724913
+          },
+          "northeast": {
+            "lat": 37.4125978,
+            "lng": 15.3367367
+          }
+        }
+      }
+    } ]
+  }
+  /
+  GOOGLE3_TOO_MANY=%q/
+    {
+       "status": "OVER_QUERY_LIMIT"
+    }
+  /
+  def setup
+    super
+    @google_full_hash = {:street_address=>"100 Spear St", :city=>"San Francisco", :state=>"CA", :zip=>"94105", :country_code=>"US"}
+    @google_city_hash = {:city=>"San Francisco", :state=>"CA"}
+
+    @google_full_loc = Geokit::GeoLoc.new(@google_full_hash)
+    @google_city_loc = Geokit::GeoLoc.new(@google_city_hash)
+  end  
+
+  def test_google3_full_address
+    response = MockSuccess.new
+    response.expects(:body).returns(GOOGLE3_FULL)
+    url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@address)}"
+    Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+    res=Geokit::Geocoders::GoogleGeocoder3.geocode(@address)
+    assert_equal "CA", res.state
+    assert_equal "San Francisco", res.city 
+    assert_equal "37.7921509,-122.394", res.ll # slightly dif from yahoo
+    assert res.is_us?
+    assert_equal "100 Spear St, San Francisco, CA 94105, USA", res.full_address #slightly different from yahoo
+    assert_equal "google3", res.provider
+  end
+  
+  def test_google3_full_address_with_geo_loc
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_FULL)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@full_address_short_zip)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.geocode(@google_full_loc)
+     assert_equal "CA", res.state
+     assert_equal "San Francisco", res.city 
+     assert_equal "37.7921509,-122.394", res.ll # slightly dif from yahoo
+     assert res.is_us?
+     assert_equal "100 Spear St, San Francisco, CA 94105, USA", res.full_address #slightly different from yahoo
+     assert_equal "google3", res.provider
+   end  
+   
+   def test_google3_full_address_accuracy
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_FULL)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@full_address_short_zip)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.geocode(@google_full_loc)
+     assert_equal 9, res.accuracy
+   end
+  
+   def test_google3_city
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_CITY)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@address)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.do_geocode(@address)
+     assert_nil res.street_address
+     assert_equal "CA", res.state
+     assert_equal "San Francisco", res.city
+     assert_equal "37.7749295,-122.4194155", res.ll
+     assert res.is_us?
+     assert_equal "San Francisco, CA, USA", res.full_address
+     assert_equal "google3", res.provider
+   end  
+   
+   def test_google3_city_accuracy
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_CITY)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@address)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.geocode(@address)
+     assert_equal 4, res.accuracy
+   end
+   
+   def test_google3_city_with_geo_loc
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_CITY)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@address)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.geocode(@google_city_loc)
+     assert_equal "CA", res.state
+     assert_equal "San Francisco", res.city
+     assert_equal "37.7749295,-122.4194155", res.ll
+     assert res.is_us?
+     assert_equal "San Francisco, CA, USA", res.full_address
+     assert_nil res.street_address
+     assert_equal "google3", res.provider
+   end  
+
+   def test_google3_suggested_bounds
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_FULL)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@full_address_short_zip)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res = Geokit::Geocoders::GoogleGeocoder3.geocode(@google_full_loc)
+     
+     assert_instance_of Geokit::Bounds, res.suggested_bounds
+     assert_equal Geokit::Bounds.new(Geokit::LatLng.new(37.7890033, -122.3971476), Geokit::LatLng.new(37.7952985, -122.3908524)), res.suggested_bounds
+   end
+   
+   def test_service_unavailable
+     response = MockFailure.new
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector::url_escape(@address)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     assert !Geokit::Geocoders::GoogleGeocoder3.geocode(@google_city_loc).success
+   end 
+   
+   def test_multiple_results
+     #Geokit::Geocoders::GoogleGeocoder3.do_geocode('via Sandro Pertini 8, Ossona, MI')
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_MULTI)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector.url_escape('via Sandro Pertini 8, Ossona, MI')}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.geocode('via Sandro Pertini 8, Ossona, MI')
+     assert_equal "Lombardy", res.state
+     assert_equal "Mesero", res.city
+     assert_equal "45.4966218,8.852694", res.ll
+     assert !res.is_us?
+     assert_equal "Via Sandro Pertini, 8, 20010 Mesero MI, Italy", res.full_address
+     assert_equal "8 Via Sandro Pertini", res.street_address
+     assert_equal "google3", res.provider
+  
+     assert_equal 2, res.all.size
+     res = res.all[1]
+     assert_equal "Lombardy", res.state
+     assert_equal "Ossona", res.city
+     assert_equal "45.5074444,8.90232", res.ll
+     assert !res.is_us?
+     assert_equal "Via Sandro Pertini, 20010 Ossona MI, Italy", res.full_address
+     assert_equal "Via Sandro Pertini", res.street_address
+     assert_equal "google3", res.provider
+   end
+  # 
+   def test_reverse_geocode
+     #Geokit::Geocoders::GoogleGeocoder3.do_reverse_geocode("40.4167413, -3.7032498")
+     madrid = Geokit::GeoLoc.new
+     madrid.lat, madrid.lng = "40.4167413", "-3.7032498"
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_REVERSE_MADRID)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&latlng=#{Geokit::Inflector::url_escape(madrid.ll)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).
+       returns(response)
+     res=Geokit::Geocoders::GoogleGeocoder3.do_reverse_geocode(madrid.ll)
+  
+     assert_equal madrid.lat.to_s.slice(1..5), res.lat.to_s.slice(1..5)
+     assert_equal madrid.lng.to_s.slice(1..5), res.lng.to_s.slice(1..5)
+     assert_equal "ES", res.country_code
+     assert_equal "google3", res.provider
+  
+     assert_equal "Madrid", res.city
+     assert_equal "Madrid", res.state
+  
+     assert_equal "Spain", res.country
+     assert_equal "street", res.precision
+     assert_equal true, res.success
+  
+     assert_equal "Calle de las Carretas, 28013 Madrid, Spain", res.full_address
+     assert_equal "28013", res.zip
+     assert_equal "Calle de las Carretas", res.street_address
+   end  
+
+   def test_country_code_biasing
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_COUNTRY_CODE_BIASED_RESULT)
+     
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=Syracuse&region=it"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     biased_result = Geokit::Geocoders::GoogleGeocoder3.geocode('Syracuse', :bias => 'it')
+     
+     assert_equal 'IT', biased_result.country_code
+     assert_equal 'Sicily', biased_result.state
+   end
+  
+   def test_too_many_queries
+     response = MockSuccess.new
+     response.expects(:body).returns(GOOGLE3_TOO_MANY)
+     url = "http://maps.google.com/maps/api/geocode/json?sensor=false&address=#{Geokit::Inflector.url_escape(@address)}"
+     Geokit::Geocoders::GoogleGeocoder3.expects(:call_geocoder_service).with(url).returns(response)
+     assert_raise Geokit::TooManyQueriesError do
+       res=Geokit::Geocoders::GoogleGeocoder3.geocode(@address)
+     end
+   end
+end

data/test/test_ipgeocoder.rb

@@ -4,8 +4,8 @@ require File.join(File.dirname(__FILE__), 'test_base_geocoder')
 class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     
   IP_FAILURE=<<-EOF
-    Country: (Private Address) (XX)
-    City: (Private Address)
+    Country: SWITZERLAND (CH)
+    City: (Unknown City)
     Latitude: 
     Longitude:
     EOF
@@ -24,10 +24,22 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     Longitude: 12.9167
     EOF
     
-    def setup
-      super
-      @success.provider = "hostip"
-    end    
+  PRIVATE_IPS_TO_TEST = [
+    '10.10.10.10',
+    '172.16.1.3',
+    '172.22.3.42',
+    '172.30.254.164',
+    '192.168.1.1',
+    '0.0.0.0',
+    '127.0.0.1',
+    '240.3.4.5',
+    '225.1.6.55'
+  ].freeze
+
+  def setup
+    super
+    @success.provider = "hostip"
+  end    
   
   def test_successful_lookup
     success = MockSuccess.new
@@ -64,14 +76,24 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
   def test_failed_lookup
     failure = MockSuccess.new
     failure.expects(:body).returns(IP_FAILURE)
-    url = 'http://api.hostip.info/get_html.php?ip=10.10.10.10&position=true'
+    url = 'http://api.hostip.info/get_html.php?ip=128.178.0.0&position=true'
     GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(failure)
-    location = GeoKit::Geocoders::IpGeocoder.geocode("10.10.10.10")
+    location = GeoKit::Geocoders::IpGeocoder.geocode("128.178.0.0")
     assert_not_nil location
     assert !location.success?
   end
   
+  def test_private_ips
+    GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).never
+    PRIVATE_IPS_TO_TEST.each do |ip|
+      location = GeoKit::Geocoders::IpGeocoder.geocode(ip)
+      assert_not_nil location
+      assert !location.success?
+    end
+  end
+  
   def test_invalid_ip
+    GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).never
     location = GeoKit::Geocoders::IpGeocoder.geocode("blah")
     assert_not_nil location
     assert !location.success?
@@ -79,9 +101,9 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
   
   def test_service_unavailable
     failure = MockFailure.new
-    url = 'http://api.hostip.info/get_html.php?ip=10.10.10.10&position=true'
+    url = 'http://api.hostip.info/get_html.php?ip=12.215.42.19&position=true'
     GeoKit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(failure)
-    location = GeoKit::Geocoders::IpGeocoder.geocode("10.10.10.10")
+    location = GeoKit::Geocoders::IpGeocoder.geocode("12.215.42.19")
     assert_not_nil location
     assert !location.success?
   end  

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: geokit
 version: !ruby/object:Gem::Version 
-  version: 1.5.0
+  hash: 15
+  prerelease: false
+  segments: 
+  - 1
+  - 6
+  - 0
+  version: 1.6.0
 platform: ruby
 authors: 
 - Andre Lewis
@@ -9,19 +15,41 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-21 00:00:00 -07:00
+date: 2011-05-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.12.2
-    version: 
+        hash: 21
+        segments: 
+        - 2
+        - 6
+        - 1
+        version: 2.6.1
+  type: :development
+  version_requirements: *id002
 description: ""
 email: 
 - andre@earthcode.com
@@ -54,6 +82,8 @@ files:
 - test/test_multi_geocoder.rb
 - test/test_us_geocoder.rb
 - test/test_yahoo_geocoder.rb
+- test/test_google_geocoder3.rb
+- test/test_multi_ip_geocoder.rb
 has_rdoc: true
 homepage: 
 licenses: []
@@ -65,21 +95,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: geokit
-rubygems_version: 1.3.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Geokit provides geocoding and distance calculation in an easy-to-use API
@@ -90,6 +126,7 @@ test_files:
 - test/test_geoloc.rb
 - test/test_geoplugin_geocoder.rb
 - test/test_google_geocoder.rb
+- test/test_google_geocoder3.rb
 - test/test_google_reverse_geocoder.rb
 - test/test_inflector.rb
 - test/test_ipgeocoder.rb