geokit 1.6.0 → 1.6.5

data/Rakefile

@@ -1,24 +1,10 @@
-# -*- ruby -*-
+require "bundler/gem_tasks"
+require 'rake/testtask'
 
-require "rake/gempackagetask"
-require 'rubygems'
-require 'hoe'
-require './lib/geokit.rb'
+task :default => :test
 
-
-# undefined method `empty?' for nil:NilClass
-# /Library/Ruby/Site/1.8/rubygems/specification.rb:886:in `validate' 
-class NilClass
-  def empty?
-    true
-  end
-end 
-
-project=Hoe.new('geokit', Geokit::VERSION) do |p|
-  #p.rubyforge_name = 'geokit' # if different than lowercase project name
-  p.developer('Andre Lewis', 'andre@earthcode.com')
-  p.summary="Geokit provides geocoding and distance calculation in an easy-to-use API"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
 end
-
-
-# vim: syntax=Ruby

data/lib/geokit.rb

@@ -1,7 +1,6 @@
 module Geokit
-  VERSION = '1.6.0'
   # These defaults are used in Geokit::Mappable.distance_to and in acts_as_mappable
-  @@default_units = :miles
+  @@default_units   = :miles
   @@default_formula = :sphere
 
   [:default_units, :default_formula].each do |sym|

data/lib/geokit/geocoders.rb

@@ -5,25 +5,20 @@ require 'yaml'
 require 'timeout'
 require 'logger'
 
-# do this just in case 
-begin 
-  ActiveSupport.nil?
-rescue NameError
-  require 'json/pure'
-end
+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').
@@ -31,54 +26,54 @@ module Geokit
       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  
-  
+  end
+
   # Contains a range of geocoders:
-  # 
-  # ### "regular" address 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 
+  # ### address geocoders that also provide reverse geocoding
   # * Google Geocoder - requires an API key.
-  #  
-  # ### IP address geocoders 
+  #
+  # ### 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    
+    @@request_timeout = nil
     @@yahoo = 'REPLACE_WITH_YOUR_YAHOO_KEY'
     @@google = 'REPLACE_WITH_YOUR_GOOGLE_KEY'
     @@geocoder_us = false
@@ -89,9 +84,9 @@ module Geokit
     @@logger=Logger.new(STDOUT)
     @@logger.level=Logger::INFO
     @@domain = nil
-    
+
     def self.__define_accessors
-      class_variables.each do |v| 
+      class_variables.each do |v|
         sym = v.to_s.delete("@").to_sym
         unless self.respond_to? sym
           module_eval <<-EOS, __FILE__, __LINE__
@@ -106,7 +101,7 @@ module Geokit
               end
               value
             end
-          
+
             def self.#{sym}=(obj)
               @@#{sym} = obj
             end
@@ -116,38 +111,38 @@ module Geokit
     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   
+    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 = {}) 
+      def self.geocode(address, options = {})
         res = do_geocode(address, options)
         return res.nil? ? GeoLoc.new : res
-      end  
+      end
       # Main method which calls the do_reverse_geocode template method which subclasses
       # are responsible for implementing.  Returns a populated GeoLoc or an
       # empty one with a failed success code.
       def self.reverse_geocode(latlng)
         res = do_reverse_geocode(latlng)
-        return res.success? ? res : GeoLoc.new        
+        return res.success? ? res : GeoLoc.new
       end
-      
+
       # Call the geocoder service using the timeout if configured.
       def self.call_geocoder_service(url)
-        Timeout::timeout(Geokit::Geocoders::request_timeout) { return self.do_get(url) } if Geokit::Geocoders::request_timeout        
+        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  
+        return nil
       end
 
       # Not all geocoders can do reverse geocoding. So, unless the subclass explicitly overrides this method,
@@ -159,14 +154,14 @@ module Geokit
 
       protected
 
-      def self.logger() 
+      def self.logger()
         Geokit::Geocoders::logger
       end
-      
+
       private
-      
+
       # Wraps the geocoder call around a proxy if necessary.
-      def self.do_get(url) 
+      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
@@ -176,8 +171,8 @@ module Geokit
                 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 
+
+      # Adds subclass' geocode method making it conveniently available through
       # the base class.
       def self.inherited(clazz)
         class_name = clazz.name.split('::').last
@@ -192,10 +187,10 @@ module Geokit
 
     # -------------------------------------------------------------------------------------------
     # "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 
+    # contain true or false based upon whether authentication is to occur.  Conforms to the
     # interface set by the Geocoder class.
     #
     # Returns a response like:
@@ -217,15 +212,15 @@ module Geokit
         xml = res.body
         logger.debug "Geocoder.ca geocoding. Address: #{address}. Result: #{xml}"
         # Parse the document.
-        doc = REXML::Document.new(xml)    
+        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  
+        return GeoLoc.new
+      end
 
       # Formats the request in the format acceptable by the CA geocoder.
       def self.construct_request(location)
@@ -243,98 +238,124 @@ module Geokit
       def self.add_ampersand(url)
         url && url.length > 0 ? "&" : ""
       end
-    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 
+    # 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         
+        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}"  
+
+        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 
+        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 
+          res.success=true
           return res
-        else 
+        else
           logger.info "geocoder.us was unable to geocode address: "+address
-          return GeoLoc.new      
+          return GeoLoc.new
         end
-        rescue 
+        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 
+      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://api.local.yahoo.com/MapsService/V1/geocode?appid=#{Geokit::Geocoders::yahoo}&location=#{Geokit::Inflector::url_escape(address_str)}"
+        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)
-        xml = res.body
-        doc = REXML::Document.new(xml)
-        logger.debug "Yahoo geocoding. Address: #{address}. Result: #{xml}"
+        json = res.body
+        logger.debug "Yahoo geocoding. Address: #{address}. Result: #{json}"
+        return self.json2GeoLoc(json, address)
+      end
 
-        if doc.elements['//ResultSet']
-          res=GeoLoc.new
+      def self.json2GeoLoc(json, address)
+        results = MultiJson.decode(json)
 
-          #basic      
-          res.lat=doc.elements['//Latitude'].text
-          res.lng=doc.elements['//Longitude'].text
-          res.country_code=doc.elements['//Country'].text
-          res.provider='yahoo'  
-
-          #extended - false if not available
-          res.city=doc.elements['//City'].text if doc.elements['//City'] && doc.elements['//City'].text != nil
-          res.state=doc.elements['//State'].text if doc.elements['//State'] && doc.elements['//State'].text != nil
-          res.zip=doc.elements['//Zip'].text if doc.elements['//Zip'] && doc.elements['//Zip'].text != nil
-          res.street_address=doc.elements['//Address'].text if doc.elements['//Address'] && doc.elements['//Address'].text != nil
-          res.precision=doc.elements['//Result'].attributes['precision'] if doc.elements['//Result']
-          # set the accuracy as google does (added by Andruby)
-          res.accuracy=%w{unknown country state state city zip zip+4 street address building}.index(res.precision)
-          res.success=true
-          return res
-        else 
-          logger.info "Yahoo was unable to geocode address: "+address
+        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
+      end
 
-        rescue 
-          logger.info "Caught an error during Yahoo geocoding call: "+$!
-          return GeoLoc.new
+      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
 
@@ -342,47 +363,47 @@ module Geokit
     # http://www.geonames.org
     class GeonamesGeocoder < Geocoder
 
-      private 
-      
+      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.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 
+        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
@@ -396,18 +417,18 @@ module Geokit
     # contain a Google API key.  Conforms to the interface set by the Geocoder class.
     class GoogleGeocoder < Geocoder
 
-      private 
-      
+      private
+
       # Template method which does the reverse-geocode lookup.
-      def self.do_reverse_geocode(latlng) 
+      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  
+        return self.xml2GeoLoc(xml)
+      end
 
       # Template method which does the geocode lookup.
       #
@@ -416,7 +437,7 @@ module Geokit
       # ==== 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, 
+      #           ('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).
       #
@@ -441,9 +462,9 @@ module Geokit
         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)        
+        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
@@ -453,24 +474,24 @@ module Geokit
           "&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. 
+          # 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? 
+            if geoloc.nil?
               # first time through, geoloc is still nil, so we make it the geoloc we just extracted
-              geoloc = extracted_geoloc 
+              geoloc = extracted_geoloc
             else
-              # second (and subsequent) iterations, we push additional 
-              # geolocs onto "geoloc.all" 
-              geoloc.all.push(extracted_geoloc) 
-            end  
+              # 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'
@@ -486,7 +507,7 @@ module Geokit
       rescue
         logger.error "Caught an error during Google geocoding call: "+$!
         return GeoLoc.new
-      end  
+      end
 
       # extracts a single geoloc from a //placemark element in the google results xml
       def self.extract_placemark(doc)
@@ -513,14 +534,14 @@ module Geokit
         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']  
+        if suggested_bounds = doc.elements['//LatLonBox']
           res.suggested_bounds = Bounds.normalize(
-                                  [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']], 
+                                  [suggested_bounds.attributes['south'], suggested_bounds.attributes['west']],
                                   [suggested_bounds.attributes['north'], suggested_bounds.attributes['east']])
         end
-        
+
         res.success=true
 
         return res
@@ -529,16 +550,16 @@ module Geokit
 
     class GoogleGeocoder3 < Geocoder
 
-      private 
+      private
       # Template method which does the reverse-geocode lookup.
-      def self.do_reverse_geocode(latlng) 
+      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  
+        return self.json2GeoLoc(json)
+      end
 
       # Template method which does the geocode lookup.
       #
@@ -547,7 +568,7 @@ module Geokit
       # ==== 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, 
+      #           ('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).
       #
@@ -568,13 +589,16 @@ module Geokit
       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)        
+
+        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
@@ -587,13 +611,8 @@ module Geokit
 
       def self.json2GeoLoc(json, address="")
         ret=nil
-        begin
-          results=::ActiveSupport::JSON.decode(json)
-        rescue NameError => e
-          results=JSON.parse(json)
-        end
-          
-        
+        results = MultiJson.decode(json)
+
         if results['status'] == 'OVER_QUERY_LIMIT'
           raise Geokit::TooManyQueriesError
         end
@@ -626,13 +645,19 @@ module Geokit
           "GEOMETRIC_CENTER" => 5,
           "APPROXIMATE" => 4
         }
-        results['results'].sort_by{|a|accuracy[a['geometry']['location_type']]}.reverse.each do |addr|
-          res=GeoLoc.new
+
+        @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")
@@ -657,16 +682,20 @@ module Geokit
           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']['lat'].to_f,
             addr['geometry']['viewport']['northeast']['lng'].to_f
             )
           sw=Geokit::LatLng.new(
@@ -675,34 +704,34 @@ module Geokit
           )
           res.suggested_bounds = Geokit::Bounds.new(sw,ne)
 
-          if ret
-            ret.all.push(res)
-          else
-            ret=res
-          end
+          @unsorted << res
         end
-        return ret
+
+        all = @unsorted.sort_by { |a| a.accuracy }.reverse
+        encoded = all.first
+        encoded.all = all
+        return encoded
       end
     end
-    
+
     class FCCGeocoder < Geocoder
 
-       private 
+       private
        # Template method which does the reverse-geocode lookup.
-       def self.do_reverse_geocode(latlng) 
+       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  
+         return self.json2GeoLoc(json)
+       end
 
        # Template method which does the geocode lookup.
        #
        # ==== EXAMPLES
        # ll=GeoKit::LatLng.new(40, -85)
-       # Geokit::Geocoders::FCCGeocoder.geocode(ll) # 
+       # Geokit::Geocoders::FCCGeocoder.geocode(ll) #
 
        # JSON result looks like this
        # => {"County"=>{"name"=>"Wayne", "FIPS"=>"18177"},
@@ -712,13 +741,9 @@ module Geokit
        # "status"=>"OK"}
 
        def self.json2GeoLoc(json, address="")
-         ret=nil
-         begin
-           results=::ActiveSupport::JSON.decode(json)
-         rescue NameError => e
-           results=JSON.parse(json)
-         end
-         
+         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
@@ -744,11 +769,11 @@ module Geokit
     # -------------------------------------------------------------------------------------------
     # 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}")
@@ -775,7 +800,7 @@ module Geokit
     # 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 
+    class IpGeocoder < Geocoder
 
       # A number of non-routable IP ranges.
       #
@@ -785,24 +810,24 @@ module Geokit
       #   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
+        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 
+      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.  
+      # 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)
@@ -828,7 +853,7 @@ module Geokit
         res.provider = 'hostip'
         res.city, res.state = yaml['City'].split(', ')
         country, res.country_code = yaml['Country'].split(' (')
-        res.lat = yaml['Latitude'] 
+        res.lat = yaml['Latitude']
         res.lng = yaml['Longitude']
         res.country_code.chop!
         res.success = !(res.city =~ /\(.+\)/)
@@ -841,36 +866,36 @@ module Geokit
       # 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) }
+        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       
+    class MultiGeocoder < Geocoder
 
       private
-      # This method will call one or more geocoders in the order specified in the 
+      # 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  
+      # 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"
@@ -883,8 +908,8 @@ module Geokit
         # If we get here, we failed completely.
         GeoLoc.new
       end
-      
-      # This method will call one or more geocoders in the order specified in the 
+
+      # 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)
@@ -900,6 +925,6 @@ module Geokit
         # If we get here, we failed completely.
         GeoLoc.new
       end
-    end   
+    end
   end
 end