geokit 1.7.1 → 1.8.0

data/lib/geokit/geocoders/ip.rb

@@ -0,0 +1,69 @@
+module Geokit
+  module Geocoders
+    # 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 < BaseIpGeocoder
+      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)
+        return GeoLoc.new unless valid_ip?(ip)
+        url = "http://api.hostip.info/get_html.php?ip=#{ip}&position=true"
+        res = call_geocoder_service(url)
+        ensure_utf8_encoding(res)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        body = res.body
+        body = body.encode('UTF-8') if body.respond_to? :encode
+        parse :yaml, body
+      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_yaml(yaml) # :nodoc:
+        loc = GeoLoc.new
+        loc.provider = 'hostip'
+        loc.city, loc.state = yaml['City'].split(', ')
+        loc.country, loc.country_code = yaml['Country'].split(' (')
+        loc.lat = yaml['Latitude']
+        loc.lng = yaml['Longitude']
+        loc.country_code.chop!
+        loc.success = !(loc.city =~ /\(.+\)/)
+        loc
+      end
+
+      # Forces UTF-8 encoding on the body
+      # Rails expects string input to be UTF-8
+      # hostip.info specifies the charset encoding in the headers
+      # thus extract encoding from headers and tell Rails about it by forcing it
+      def self.ensure_utf8_encoding(res)
+        if (enc_string = extract_charset(res))
+          if defined?(Encoding) && Encoding.aliases.values.include?(enc_string.upcase)
+            res.body.force_encoding(enc_string.upcase) if res.body.respond_to?(:force_encoding)
+            res.body.encode("UTF-8")
+          else
+            require 'iconv'
+            res.body.replace Iconv.conv("UTF8", "iso88591", res.body)
+          end
+        end
+      end
+
+      # Extracts charset out of the response headers
+      def self.extract_charset(res)
+        if (content_type = res['content-type'])
+          capture = content_type.match(/charset=(.+)/)
+          capture && capture[1]
+        end
+      end
+    end
+  end
+end
+

data/lib/geokit/geocoders/mapquest.rb

@@ -0,0 +1,72 @@
+module Geokit
+  module Geocoders
+    # MapQuest geocoder implementation.  Requires the Geokit::Geocoders::mapquest variable to
+    # contain a MapQuest API key.  Conforms to the interface set by the Geocoder class.
+    class MapQuestGeocoder < Geocoder
+
+      private
+
+      # Template method which does the reverse-geocode lookup.
+      def self.do_reverse_geocode(latlng)
+        latlng=LatLng.normalize(latlng)
+        url = "http://www.mapquestapi.com/geocoding/v1/reverse?key=#{Geokit::Geocoders::mapquest}&location=#{latlng.lat},#{latlng.lng}"
+        res = call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "MapQuest reverse-geocoding. LL: #{latlng}. Result: #{json}"
+        parse :json, json, latlng
+      end
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address)
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        url = "http://www.mapquestapi.com/geocoding/v1/address?key=#{Geokit::Geocoders::mapquest}&location=#{Geokit::Inflector::url_escape(address_str)}"
+        res = call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "Mapquest geocoding. Address: #{address}. Result: #{json}"
+        parse :json, json
+      end
+
+      def self.parse_json(results)
+        return GeoLoc.new unless results['info']['statuscode'] == 0
+        loc = nil
+        results['results'].each do |result|
+          result['locations'].each do |location|
+            extracted_geoloc = extract_geoloc(location)
+            if loc.nil?
+              loc = extracted_geoloc
+            else
+              loc.all.push(extracted_geoloc)
+            end
+          end
+        end          
+        loc
+      end
+
+      def self.extract_geoloc(result_json)
+        loc = GeoLoc.new
+        loc.lat            = result_json['latLng']['lat']
+        loc.lng            = result_json['latLng']['lng']
+        loc.provider       = 'mapquest'
+        set_address_components(result_json, loc)
+        set_precision(result_json, loc)
+        loc.success = true
+        loc
+      end
+
+      def self.set_address_components(result_json, loc)
+        loc.country_code   = result_json['adminArea1']
+        loc.street_address = result_json['street'].to_s.empty? ? nil : result_json['street']
+        loc.city           = result_json['adminArea5']
+        loc.state          = result_json['adminArea3']
+        loc.zip            = result_json['postalCode']
+      end
+
+      def self.set_precision(result_json, loc)
+        loc.precision = result_json['geocodeQuality']
+        loc.accuracy = %w{unknown country state state city zip zip+4 street address building}.index(loc.precision)
+      end
+    end
+  end
+end

data/lib/geokit/geocoders/maxmind.rb

@@ -0,0 +1,29 @@
+module Geokit
+  module Geocoders
+
+  @@geoip_data_path = 'DEFINE_THE_PATH_TO_GeoLiteCity.dat'
+  __define_accessors
+
+    # Provides geocoding based upon an IP address.  The underlying web service is MaxMind
+    class MaxmindGeocoder < Geocoder
+      private
+
+      def self.do_geocode(ip)
+        res = GeoIP.new(Geokit::Geocoders::geoip_data_path).city(ip)
+
+        loc = GeoLoc.new(
+          :provider => 'maxmind_city',
+          :lat      => res.latitude,
+          :lng      => res.longitude,
+          :city     => res.city_name,
+          :state    => res.region_name,
+          :zip      => res.postal_code,
+          :country_code => res.country_code2
+        )
+
+        loc.success = ( res.longitude.kind_of?(Numeric) && res.latitude.kind_of?(Numeric) )
+        loc
+      end
+    end
+  end
+end

data/lib/geokit/geocoders/openstreetmap.rb

@@ -0,0 +1,119 @@
+module Geokit
+  module Geocoders
+    # Open Street Map geocoder implementation.
+    class OSMGeocoder < Geocoder
+
+      private
+
+      # Template method which does the geocode lookup.
+      def self.do_geocode(address, options = {})
+        options_str = generate_bool_param_for_option(:polygon, options)
+        options_str << generate_param_for_option(:json_callback, options)
+        options_str << generate_param_for_option(:countrycodes, options)
+        options_str << generate_param_for_option(:viewbox, options)
+
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+
+        url = "http://nominatim.openstreetmap.org/search?format=json#{options_str}&addressdetails=1&q=#{Geokit::Inflector::url_escape(address_str)}"
+        res = call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "OSM geocoding. Address: #{address}. Result: #{json}"
+        parse :json, json
+      end
+
+      def self.do_reverse_geocode(latlng, options = {})
+        latlng = LatLng.normalize(latlng)
+        options_str = generate_param_for(:lat, latlng.lat)
+        options_str << generate_param_for(:lon, latlng.lng)
+        options_str << generate_param_for_option(:zoom, options)
+        options_str << generate_param_for_option(:osm_type, options)
+        options_str << generate_param_for_option(:osm_id, options)
+        options_str << generate_param_for_option(:json_callback, options)
+        url = "http://nominatim.openstreetmap.org/reverse?format=json&addressdetails=1#{options_str}"
+        res = call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        json = res.body
+        logger.debug "OSM reverse geocoding: Lat: #{latlng.lat}, Lng: #{latlng.lng}. Result: #{json}"
+        parse :json, json
+      end
+
+      def self.generate_param_for(param, value)
+        "&#{param}=#{Geokit::Inflector::url_escape(value.to_s)}"
+      end
+
+      def self.generate_param_for_option(param, options)
+        options[param] ? "&#{param}=#{Geokit::Inflector::url_escape(options[param])}" : ''
+      end
+
+      def self.generate_bool_param_for_option(param, options)
+        options[param] ? "&#{param}=1" : "&#{param}=0"
+      end
+
+      def self.parse_json(results)
+        if results.is_a?(Hash)
+          return GeoLoc.new if results['error']
+          results = [results]
+        end
+        return GeoLoc.new if results.empty?
+
+        loc = nil
+        results.each do |result|
+          extract_geoloc = extract_geoloc(result)
+          if loc.nil?
+            loc = extract_geoloc
+          else
+            loc.all.push(extract_geoloc)
+          end
+        end
+        loc
+      end
+
+      def self.extract_geoloc(result_json)
+        loc = GeoLoc.new
+
+        # basic
+        loc.lat = result_json['lat']
+        loc.lng = result_json['lon']
+
+        loc.provider = 'osm'
+
+        set_address_components(result_json['address'], loc)
+        set_precision(result_json, loc)
+        set_bounds(result_json['boundingbox'], loc)
+        loc.success = true
+
+        loc
+      end
+
+      def self.set_address_components(address_data, loc)
+        return unless address_data
+        loc.country = address_data['country']
+        loc.country_code = address_data['country_code'].upcase if address_data['country_code']
+        loc.state = address_data['state']
+        loc.city = address_data['city']
+        loc.city = address_data['county'] if loc.city.nil? && address_data['county']
+        loc.zip = address_data['postcode']
+        loc.district = address_data['city_district']
+        loc.district = address_data['state_district'] if loc.district.nil? && address_data['state_district']
+        loc.street_address = "#{address_data['road']} #{address_data['house_number']}".strip if address_data['road']
+        loc.street_name = address_data['road']
+        loc.street_number = address_data['house_number']
+      end
+
+      def self.set_precision(result_json, loc)
+        # Todo accuracy does not work as Yahoo and Google maps on OSM
+        #loc.accuracy = %w{unknown amenity building highway historic landuse leisure natural place railway shop tourism waterway man_made}.index(loc.precision)
+        loc.precision = result_json['class']
+        loc.accuracy = result_json['type']
+      end
+
+      def self.set_bounds(result_json, loc)
+        return unless result_json
+        loc.suggested_bounds = Bounds.normalize(
+            [result_json[0], result_json[1]],
+            [result_json[2], result_json[3]])
+      end
+    end
+  end
+end

data/lib/geokit/geocoders/ripe.rb

@@ -0,0 +1,41 @@
+module Geokit
+  module Geocoders
+    # Provides geocoding based upon an IP address.  The underlying web service is geoplugin.net
+    class RipeGeocoder < BaseIpGeocoder
+      private
+
+      def self.do_geocode(ip)
+        return GeoLoc.new unless valid_ip?(ip)
+        url = "http://stat.ripe.net/data/geoloc/data.json?resource=#{ip}"
+        res = call_geocoder_service(url)
+        return GeoLoc.new if !res.is_a?(Net::HTTPSuccess)
+        parse :json, res.body
+      end
+
+      def self.parse_json(json)
+        loc = GeoLoc.new
+        data = json['data']['locations'][0]
+
+        loc.provider='RIPE'
+        loc.lat = data['latitude']
+        loc.lng = data['longitude']
+        set_address_components(data, loc)
+        loc.success = (data['status_code'] == 200)
+        loc
+      end
+
+      def self.set_address_components(data, loc)
+        match = data['country'].match /([A-Z]+)(\(([A-Z]+)\))?/
+        if match[3]
+          loc.state = match[1]
+          loc.country_code = match[3]
+        else
+          loc.country_code = match[1]
+        end
+
+        loc.city = data['city']
+      end
+    end
+
+  end
+end

data/lib/geokit/{services → geocoders}/us_geocoder.rb

@@ -6,7 +6,7 @@ module Geokit
     class UsGeocoder < Geocoder
 
       private
-      def self.do_geocode(address, options = {})
+      def self.do_geocode(address)
         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)}"
@@ -17,34 +17,29 @@ module Geokit
         end
 
         url = "#{url}?#{query}"
-        res = self.call_geocoder_service(url)
+        res = 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}"
+        parse_csv data
+      end
+
+      def self.parse_csv(data)
         array = data.chomp.split(',')
 
+        loc = GeoLoc.new
         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
+          loc.lat,loc.lng,loc.city,loc.state,loc.zip=array
+          loc.country_code='US'
+          loc.success=true
         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
+          loc.lat,loc.lng,loc.street_address,loc.city,loc.state,loc.zip=array
+          loc.country_code='US'
+          loc.success=true
         end
-        rescue
-          logger.error "Caught an error during geocoder.us geocoding call: "+$!
-          return GeoLoc.new
-
+        loc
       end
     end
- end
+  end
 end

data/lib/geokit/{services → geocoders}/yahoo.rb

@@ -5,79 +5,77 @@ module Geokit
     class YahooGeocoder < Geocoder
 
       private
-      def self.submit_url(query_string)
+      def self.submit_url(address)
+        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
+        query_string = "?q=#{Geokit::Inflector::url_escape(address_str)}&flags=J"
+
         o = OauthUtil.new
         o.consumer_key = Geocoders::yahoo_consumer_key
         o.consumer_secret = Geocoders::yahoo_consumer_secret
         base = "http://yboss.yahooapis.com/geo/placefinder"
         parsed_url = URI.parse("#{base}#{query_string}")
-        "http://yboss.yahooapis.com/geo/placefinder?#{o.sign(parsed_url).query_string}"
+        "#{base}?#{o.sign(parsed_url).query_string}"
       end
 
       # Template method which does the geocode lookup.
-      def self.do_geocode(address, options = {})
-        address_str = address.is_a?(GeoLoc) ? address.to_geocodeable_s : address
-        submit_url = submit_url("?q=#{Geokit::Inflector::url_escape(address_str)}&flags=J")
-
-        res = self.call_geocoder_service(submit_url)
+      def self.do_geocode(address)
+        url = submit_url(address)
+        res = 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)
+        parse :json, json
       end
 
-      def self.json2GeoLoc(json, address)
-        results = MultiJson.load(json)
-
-        if results && results['bossresponse'] && results['bossresponse']['placefinder'] && results['bossresponse']['placefinder']['results'] && results['bossresponse']['placefinder']['results'].first != nil
-          geoloc = nil
-          results['bossresponse']['placefinder']['results'].each do |result|
-            extracted_geoloc = extract_geoloc(result)
-            if geoloc.nil?
-              geoloc = extracted_geoloc
-            else
-              geoloc.all.push(extracted_geoloc)
-            end
+      def self.parse_json(results)
+        boss_results = results && results['bossresponse'] && results['bossresponse']['placefinder'] && results['bossresponse']['placefinder']['results']
+        return GeoLoc.new unless boss_results && boss_results.first
+        loc = nil
+        boss_results.each do |result|
+          extracted_geoloc = extract_geoloc(result)
+          if loc.nil?
+            loc = extracted_geoloc
+          else
+            loc.all.push(extracted_geoloc)
           end
-          return geoloc
-        else
-          logger.info "Yahoo was unable to geocode address: " + address
-          return GeoLoc.new
         end
+        loc
       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']
+        loc = GeoLoc.new
+        loc.lat      = result_json['latitude']
+        loc.lng      = result_json['longitude']
+        loc.provider = 'yahoo'
+        set_address_components(result_json, loc)
+        set_precision(result_json, loc)
+        loc.success  = true
+        loc
+      end
 
-        geoloc.precision = case result_json['quality'].to_i
-                           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
+      def self.set_address_components(result_json, loc)
+        loc.country_code   = result_json['countrycode']
+        loc.street_address = result_json['line1'].to_s.empty? ? nil : result_json['line1']
+        loc.city           = result_json['city']
+        loc.state          = loc.is_us? ? result_json['statecode'] : result_json['state']
+        loc.zip            = result_json['postal']
+      end
 
-        geoloc.accuracy = %w{unknown country state state city zip zip+4 street address building}.index(geoloc.precision)
-        geoloc.success = true
+      def self.set_precision(result_json, loc)
+        loc.precision = case result_json['quality'].to_i
+                        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
 
-        return geoloc
+        loc.accuracy = %w{unknown country state state city zip zip+4 street address building}.index(loc.precision)
       end
     end
   end
@@ -118,9 +116,8 @@ class OauthUtil
   end
   
   def percent_encode( string )
-    
     # ref http://snippets.dzone.com/posts/show/1260
-    return URI.escape( string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]") ).gsub('*', '%2A')
+    URI.escape( string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]") ).gsub('*', '%2A')
   end
   
   # @ref http://oauth.net/core/1.0/#rfc.section.9.2
@@ -190,6 +187,6 @@ class OauthUtil
     # add signature
     @params[ 'oauth_signature' ] = signature
     
-    return self
+    self
   end
 end