geocoder 1.4.9 → 1.5.0

data/lib/generators/geocoder/config/templates/initializer.rb

@@ -1,7 +1,7 @@
 Geocoder.configure(
   # Geocoding options
   # timeout: 3,                 # geocoding service timeout (secs)
-  # lookup: :google,            # name of geocoding service (symbol)
+  # lookup: :nominatim,         # name of geocoding service (symbol)
   # ip_lookup: :ipinfo_io,      # name of IP address geocoding service (symbol)
   # language: :en,              # ISO-639 language code
   # use_https: false,           # use HTTPS for lookup requests? (if supported)

data/lib/geocoder/cli.rb

@@ -97,7 +97,7 @@ module Geocoder
       end
 
       if (result = Geocoder.search(query).first)
-        google = Geocoder::Lookup.get(:google)
+        nominatim = Geocoder::Lookup.get(:nominatim)
         lines = [
           ["Latitude",       result.latitude],
           ["Longitude",      result.longitude],
@@ -106,7 +106,7 @@ module Geocoder
           ["State/province", result.state],
           ["Postal code",    result.postal_code],
           ["Country",        result.country],
-          ["Google map",     google.map_link_url(result.coordinates)],
+          ["Map",            nominatim.map_link_url(result.coordinates)],
         ]
         lines.each do |line|
           out << (line[0] + ": ").ljust(18) + line[1].to_s + "\n"

data/lib/geocoder/configuration.rb

@@ -97,7 +97,7 @@ module Geocoder
 
       # geocoding options
       @data[:timeout]      = 3           # geocoding service timeout (secs)
-      @data[:lookup]       = :google     # name of street address geocoding service (symbol)
+      @data[:lookup]       = :nominatim  # name of street address geocoding service (symbol)
       @data[:ip_lookup]    = :ipinfo_io  # name of IP address geocoding service (symbol)
       @data[:language]     = :en         # ISO-639 language code
       @data[:http_headers] = {}          # HTTP headers for lookup

data/lib/geocoder/exceptions.rb

@@ -1,4 +1,4 @@
-require 'timeout' # required for Ruby 1.9.3
+require 'timeout'
 
 module Geocoder
 

data/lib/geocoder/ip_address.rb

@@ -3,7 +3,7 @@ module Geocoder
   class IpAddress < String
 
     def loopback?
-      valid? and (self == "0.0.0.0" or self.match(/\A127\./) or self == "::1")
+      valid? and !!(self == "0.0.0.0" or self.match(/\A127\./) or self == "::1")
     end
 
     def valid?

data/lib/geocoder/lookup.rb

@@ -39,14 +39,12 @@ module Geocoder
         :mapquest,
         :mapzen,
         :opencagedata,
-        :ovi,
         :pelias,
         :pickpoint,
         :here,
         :baidu,
         :geocodio,
         :smarty_streets,
-        :okf,
         :postcode_anywhere_uk,
         :postcodes_io,
         :geoportail_lu,
@@ -75,6 +73,7 @@ module Geocoder
         :ipdata_co,
         :db_ip_com,
         :ipstack,
+        :ip2location
       ]
     end
 

data/lib/geocoder/lookups/amap.rb

@@ -12,13 +12,17 @@ module Geocoder::Lookup
       ["key"]
     end
 
-    def query_url(query)
-      path = query.reverse_geocode? ? 'regeo' : 'geo'
-      "http://restapi.amap.com/v3/geocode/#{path}?" + url_query_string(query)
+    def supported_protocols
+      [:http]
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      path = query.reverse_geocode? ? 'regeo' : 'geo'
+      "http://restapi.amap.com/v3/geocode/#{path}?"
+    end
+
     def results(query, reverse = false)
       return [] unless doc = fetch_data(query)
       case [doc['status'], doc['info']]

data/lib/geocoder/lookups/baidu.rb

@@ -12,10 +12,6 @@ module Geocoder::Lookup
       ["key"]
     end
 
-    def query_url(query)
-      "#{protocol}://api.map.baidu.com/geocoder/v2/?" + url_query_string(query)
-    end
-
     # HTTP only
     def supported_protocols
       [:http]
@@ -23,26 +19,34 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://api.map.baidu.com/geocoder/v2/?"
+    end
+
+    def content_key
+      'result'
+    end
+
     def results(query, reverse = false)
       return [] unless doc = fetch_data(query)
       case doc['status']
       when 0
-        return [doc['result']] unless doc['result'].blank?
+        return [doc[content_key]] unless doc[content_key].blank?
       when 1, 3, 4
         raise_error(Geocoder::Error, "server error.") ||
-          Geocoder.log(:warn, "Baidu Geocoding API error: server error.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: server error.")
       when 2
         raise_error(Geocoder::InvalidRequest, "invalid request.") ||
-          Geocoder.log(:warn, "Baidu Geocoding API error: invalid request.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request.")
       when 5
         raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
-          Geocoder.log(:warn, "Baidu Geocoding API error: invalid api key.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
       when 101, 102, 200..299
         raise_error(Geocoder::RequestDenied, "request denied") ||
-          Geocoder.log(:warn, "Baidu Geocoding API error: request denied.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: request denied.")
       when 300..399
         raise_error(Geocoder::OverQueryLimitError, "over query limit.") ||
-          Geocoder.log(:warn, "Baidu Geocoding API error: over query limit.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: over query limit.")
       end
       return []
     end

data/lib/geocoder/lookups/baidu_ip.rb

@@ -2,49 +2,20 @@ require 'geocoder/lookups/base'
 require 'geocoder/results/baidu_ip'
 
 module Geocoder::Lookup
-  class BaiduIp < Base
+  class BaiduIp < Baidu
 
     def name
       "Baidu IP"
     end
 
-    def required_api_key_parts
-      ["key"]
-    end
-
-    def query_url(query)
-      "#{protocol}://api.map.baidu.com/location/ip?" + url_query_string(query)
-    end
+    private # ---------------------------------------------------------------
 
-    # HTTP only
-    def supported_protocols
-      [:http]
+    def base_query_url(query)
+      "#{protocol}://api.map.baidu.com/location/ip?"
     end
 
-    private # ---------------------------------------------------------------
-
-    def results(query, reverse = false)
-      return [] unless doc = fetch_data(query)
-      case doc['status']
-      when 0
-        return [doc['content']] unless doc['content'].blank?
-      when 1, 3, 4
-        raise_error(Geocoder::Error, "server error.") ||
-          Geocoder.log(:warn, "Baidu IP Geocoding API error: server error.")
-      when 2
-        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
-          Geocoder.log(:warn, "Baidu IP Geocoding API error: invalid request.")
-      when 5
-        raise_error(Geocoder::InvalidApiKey, "invalid api key.") ||
-          Geocoder.log(:warn, "Baidu IP Geocoding API error: invalid api key.")
-      when 101, 102, 200..299
-        raise_error(Geocoder::RequestDenied, "request denied.") ||
-          Geocoder.log(:warn, "Baidu IP Geocoding API error: request denied.")
-      when 300..399
-        raise_error(Geocoder::OverQueryLimitError, "over query limit") ||
-          Geocoder.log(:warn, "Baidu IP Geocoding API error: over query limit.")
-      end
-      return []
+    def content_key
+      'content'
     end
 
     def query_url_params(query)

data/lib/geocoder/lookups/ban_data_gouv_fr.rb

@@ -14,13 +14,13 @@ module Geocoder::Lookup
       "https://www.openstreetmap.org/#map=19/#{coordinates.join('/')}"
     end
 
-    def query_url(query)
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
       method = query.reverse_geocode? ? "reverse" : "search"
-      "#{protocol}://api-adresse.data.gouv.fr/#{method}/?" + url_query_string(query)
+      "#{protocol}://api-adresse.data.gouv.fr/#{method}/?"
     end
 
-    private # ---------------------------------------------------------------
-
     def any_result?(doc)
       doc['features'].any?
     end

data/lib/geocoder/lookups/base.rb

@@ -4,7 +4,6 @@ require 'uri'
 
 unless defined?(ActiveSupport::JSON)
   begin
-    require 'rubygems' # for Ruby 1.8
     require 'json'
   rescue LoadError
     raise LoadError, "Please install the 'json' or 'json_pure' gem to parse geocoder results."
@@ -72,8 +71,12 @@ module Geocoder
       ##
       # URL to use for querying the geocoding engine.
       #
+      # Subclasses should not modify this method. Instead they should define
+      # base_query_url and url_query_string. If absolutely necessary to
+      # subclss this method, they must also subclass #cache_key.
+      #
       def query_url(query)
-        fail
+        base_query_url(query) + url_query_string(query)
       end
 
       ##
@@ -97,6 +100,14 @@ module Geocoder
 
       private # -------------------------------------------------------------
 
+      ##
+      # String which, when concatenated with url_query_string(query)
+      # produces the full query URL. Should include the "?" a the end.
+      #
+      def base_query_url(query)
+        fail
+      end
+
       ##
       # An object with configuration data for this particular lookup.
       #
@@ -147,7 +158,14 @@ module Geocoder
       # something else (like the URL before OAuth encoding).
       #
       def cache_key(query)
-        query_url(query)
+        base_query_url(query) + hash_to_query(cache_key_params(query))
+      end
+
+      def cache_key_params(query)
+        # omit api_key and token because they may vary among requests
+        query_url_params(query).reject do |key,value|
+          key.to_s.match /(key|token)/
+        end
       end
 
       ##

data/lib/geocoder/lookups/bing.rb

@@ -16,24 +16,20 @@ module Geocoder::Lookup
       ["key"]
     end
 
-    def query_url(query)
-      base_url(query) + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
-    def base_url(query)
-      url = "#{protocol}://dev.virtualearth.net/REST/v1/Locations"
-
-      if !query.reverse_geocode?
+    def base_query_url(query)
+      text = CGI.escape(query.sanitized_text.strip)
+      url = "#{protocol}://dev.virtualearth.net/REST/v1/Locations/"
+      if query.reverse_geocode?
+        url + "#{text}?"
+      else
         if r = query.options[:region]
-          url << "/#{r}"
+          url << "#{r}/"
         end
         # use the more forgiving 'unstructured' query format to allow special
         # chars, newlines, brackets, typos.
-        url + "?q=" + URI.escape(query.sanitized_text.strip) + "&"
-      else
-        url + "/#{URI.escape(query.sanitized_text.strip)}?"
+        url + "?q=#{text}&"
       end
     end
 

data/lib/geocoder/lookups/db_ip_com.rb

@@ -16,15 +16,18 @@ module Geocoder::Lookup
       ['api_key']
     end
 
-    def query_url(query)
-      query_params = if query.options[:params]
-        "?#{url_query_string(query)}"
-      end
+    private # ----------------------------------------------------------------
 
-      "#{protocol}://api.db-ip.com/v2/#{configuration.api_key}/#{query.sanitized_text}#{query_params}"
+    def base_query_url(query)
+      "#{protocol}://api.db-ip.com/v2/#{configuration.api_key}/#{query.sanitized_text}?"
     end
 
-    private
+    ##
+    # Same as query_url but without the api key.
+    #
+    def cache_key(query)
+      "#{protocol}://api.db-ip.com/v2/#{query.sanitized_text}?" + hash_to_query(cache_key_params(query))
+    end
 
     def results(query)
       return [] unless (doc = fetch_data(query))

data/lib/geocoder/lookups/dstk.rb

@@ -12,9 +12,11 @@ module Geocoder::Lookup
       "Data Science Toolkit"
     end
 
-    def query_url(query)
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
       host = configuration[:host] || "www.datasciencetoolkit.org"
-      "#{protocol}://#{host}/maps/api/geocode/json?" + url_query_string(query)
+      "#{protocol}://#{host}/maps/api/geocode/json?"
     end
   end
 end

data/lib/geocoder/lookups/esri.rb

@@ -4,15 +4,11 @@ require 'geocoder/esri_token'
 
 module Geocoder::Lookup
   class Esri < Base
-    
+
     def name
       "Esri"
     end
 
-    def query_url(query)
-      base_query_url(query) + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
     def base_query_url(query)
@@ -34,17 +30,6 @@ module Geocoder::Lookup
       end
     end
 
-    def cache_key(query)
-      base_query_url(query) + hash_to_query(cache_key_params(query))
-    end
-
-    def cache_key_params(query)
-      # omit api_key and token because they may vary among requests
-      query_url_params(query).reject do |key,value|
-        [:api_key, :token].include?(key)
-      end
-    end
-
     def query_url_params(query)
       params = {
         :f => "pjson",

data/lib/geocoder/lookups/freegeoip.rb

@@ -23,6 +23,10 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def cache_key(query)
+      query_url(query)
+    end
+
     def parse_raw_data(raw_data)
       raw_data.match(/^<html><title>404/) ? nil : super(raw_data)
     end

data/lib/geocoder/lookups/geocoder_ca.rb

@@ -8,12 +8,12 @@ module Geocoder::Lookup
       "Geocoder.ca"
     end
 
-    def query_url(query)
-      "#{protocol}://geocoder.ca/?" + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://geocoder.ca/?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       if doc['error'].nil?

data/lib/geocoder/lookups/geocoder_us.rb

@@ -8,20 +8,28 @@ module Geocoder::Lookup
       "Geocoder.us"
     end
 
-      def supported_protocols
-        [:http]
-      end
+    def supported_protocols
+      [:http]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      base_query_url_with_optional_key(configuration.api_key)
+    end
 
-    def query_url(query)
+    def cache_key(query)
+      base_query_url_with_optional_key(nil) + url_query_string(query)
+    end
+
+    def base_query_url_with_optional_key(key = nil)
+      base = "#{protocol}://"
       if configuration.api_key
-        "#{protocol}://#{configuration.api_key}@geocoder.us/member/service/csv/geocode?" + url_query_string(query)
-      else
-        "#{protocol}://geocoder.us/service/csv/geocode?" + url_query_string(query)
+        base << "#{configuration.api_key}@"
       end
+      base + "geocoder.us/member/service/csv/geocode?"
     end
 
-    private
-
     def results(query)
       return [] unless doc = fetch_data(query)
       if doc[0].to_s =~ /^(\d+)\:/