geocoder 1.4.3 → 1.6.1

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
 
       ##
@@ -179,6 +197,8 @@ module Geocoder
         raise_error(err) or Geocoder.log(:warn, "Geocoding API connection cannot be established.")
       rescue Errno::ECONNREFUSED => err
         raise_error(err) or Geocoder.log(:warn, "Geocoding API connection refused.")
+      rescue Geocoder::NetworkError => err
+        raise_error(err) or Geocoder.log(:warn, "Geocoding API connection is either unreacheable or reset by the peer")
       rescue Timeout::Error => err
         raise_error(err) or Geocoder.log(:warn, "Geocoding API not responding fast enough " +
           "(use Geocoder.configure(:timeout => ...) to set limit).")
@@ -191,7 +211,10 @@ module Geocoder
           JSON.parse(data)
         end
       rescue
-        raise_error(ResponseParseError.new(data)) or Geocoder.log(:warn, "Geocoding API's response was not valid JSON: #{data}")
+        unless raise_error(ResponseParseError.new(data))
+          Geocoder.log(:warn, "Geocoding API's response was not valid JSON")
+          Geocoder.log(:debug, "Raw response: #{data}")
+        end
       end
 
       ##
@@ -286,7 +309,7 @@ module Geocoder
         end
       rescue Timeout::Error
         raise Geocoder::LookupTimeout
-      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ENETUNREACH
+      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ENETUNREACH, Errno::ECONNRESET
         raise Geocoder::NetworkError
       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
 
@@ -44,6 +40,11 @@ module Geocoder::Lookup
         return doc['resourceSets'].first['estimatedTotal'] > 0 ? doc['resourceSets'].first['resources'] : []
       elsif doc['statusCode'] == 401 and doc["authenticationResultCode"] == "InvalidCredentials"
         raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid Bing API key.")
+      elsif doc['statusCode'] == 403
+        raise_error(Geocoder::RequestDenied) || Geocoder.log(:warn, "Bing Geocoding API error: Forbidden Request")
+      elsif [500, 503].include?(doc['statusCode'])
+        raise_error(Geocoder::ServiceUnavailable) ||
+          Geocoder.log(:warn, "Bing Geocoding API error: Service Unavailable")
       else
         Geocoder.log(:warn, "Bing Geocoding API error: #{doc['statusCode']} (#{doc['statusDescription']}).")
       end
@@ -52,7 +53,8 @@ module Geocoder::Lookup
 
     def query_url_params(query)
       {
-        key: configuration.api_key
+        key: configuration.api_key,
+        language: (query.language || configuration.language)
       }.merge(super)
     end
 

data/lib/geocoder/lookups/db_ip_com.rb

@@ -0,0 +1,52 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/db_ip_com'
+
+module Geocoder::Lookup
+  class DbIpCom < Base
+
+    def name
+      'DB-IP.com'
+    end
+
+    def supported_protocols
+      [:https, :http]
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.db-ip.com/v2/#{configuration.api_key}/#{query.sanitized_text}?"
+    end
+
+    ##
+    # 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))
+
+      case doc['error']
+      when 'maximum number of queries per day exceeded'
+        raise_error Geocoder::OverQueryLimitError ||
+                    Geocoder.log(:warn, 'DB-API query limit exceeded.')
+
+      when 'invalid API key'
+        raise_error Geocoder::InvalidApiKey ||
+                    Geocoder.log(:warn, 'Invalid DB-IP API key.')
+      when nil
+        [doc]
+
+      else
+        raise_error Geocoder::Error ||
+                    Geocoder.log(:warn, "Request failed: #{doc['error']}")
+      end
+    end
+  end
+end

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",
@@ -55,31 +40,56 @@ module Geocoder::Lookup
       else
         params[:text] = query.sanitized_text
       end
-      params[:token] = token
-      params[:forStorage] = configuration[:for_storage] if configuration[:for_storage]
+
+      params[:token] = token(query)
+
+      if for_storage_value = for_storage(query)
+        params[:forStorage] = for_storage_value
+      end
       params[:sourceCountry] = configuration[:source_country] if configuration[:source_country]
       params.merge(super)
     end
 
-    def token
-      create_and_save_token! if !valid_token_configured? and configuration.api_key
-      configuration[:token].to_s unless configuration[:token].nil?
+    def for_storage(query)
+      if query.options.has_key?(:for_storage)
+        query.options[:for_storage]
+      else
+        configuration[:for_storage]
+      end
+    end
+
+    def token(query)
+      token_instance = if query.options[:token]
+                         query.options[:token]
+                       else
+                         configuration[:token]
+                       end
+
+      if !valid_token_configured?(token_instance) && configuration.api_key
+        token_instance = create_and_save_token!(query)
+      end
+
+      token_instance.to_s unless token_instance.nil?
     end
 
-    def valid_token_configured?
-      !configuration[:token].nil? and configuration[:token].active?
+    def valid_token_configured?(token_instance)
+      !token_instance.nil? && token_instance.active?
     end
 
-    def create_and_save_token!
-      save_token!(create_token)
+    def create_and_save_token!(query)
+      token_instance = create_token
+
+      if query.options[:token]
+        query.options[:token] = token_instance
+      else
+        Geocoder.merge_into_lookup_config(:esri, token: token_instance)
+      end
+
+      token_instance
     end
 
     def create_token
       Geocoder::EsriToken.generate_token(*configuration.api_key)
     end
-
-    def save_token!(token_instance)
-      Geocoder.merge_into_lookup_config(:esri, token: token_instance)
-    end
   end
 end

data/lib/geocoder/lookups/freegeoip.rb

@@ -7,9 +7,14 @@ module Geocoder::Lookup
     def name
       "FreeGeoIP"
     end
-    
+
     def supported_protocols
-      [:http]
+      if configuration[:host]
+        [:https]
+      else
+        # use https for default host
+        [:https]
+      end
     end
 
     def query_url(query)
@@ -18,13 +23,17 @@ 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
 
     def results(query)
-      # don't look up a loopback address, just return the stored result
-      return [reserved_result(query.text)] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
       # note: Freegeoip.net returns plain text "Not Found" on bad request
       (doc = fetch_data(query)) ? [doc] : []
     end
@@ -35,8 +44,8 @@ module Geocoder::Lookup
         "city"         => "",
         "region_code"  => "",
         "region_name"  => "",
-        "metrocode"    => "",
-        "zipcode"      => "",
+        "metro_code"    => "",
+        "zip_code"      => "",
         "latitude"     => "0",
         "longitude"    => "0",
         "country_name" => "Reserved",
@@ -45,7 +54,7 @@ module Geocoder::Lookup
     end
 
     def host
-      configuration[:host] || "freegeoip.io"
+      configuration[:host] || "freegeoip.app"
     end
   end
 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/geocodio.rb

@@ -8,11 +8,6 @@ module Geocoder::Lookup
       "Geocodio"
     end
 
-    def query_url(query)
-      path = query.reverse_geocode? ? "reverse" : "geocode"
-      "#{protocol}://api.geocod.io/v1/#{path}?#{url_query_string(query)}"
-    end
-
     def results(query)
       return [] unless doc = fetch_data(query)
       return doc["results"] if doc['error'].nil?
@@ -32,6 +27,11 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1.3/#{path}?"
+    end
+
     def query_url_params(query)
       {
         :api_key => configuration.api_key,

data/lib/geocoder/lookups/geoportail_lu.rb

@@ -9,14 +9,14 @@ module Geocoder
         "Geoportail.lu"
       end
 
-      def query_url(query)
-        url_base_path(query) + url_query_string(query)
-      end
-
-      private
+      private # ---------------------------------------------------------------
 
-      def url_base_path(query)
-        query.reverse_geocode? ? reverse_geocode_url_base_path : search_url_base_path
+      def base_query_url(query)
+        if query.reverse_geocode?
+          reverse_geocode_url_base_path
+        else
+          search_url_base_path
+        end
       end
 
       def search_url_base_path

data/lib/geocoder/lookups/google.rb

@@ -21,12 +21,12 @@ module Geocoder::Lookup
       end
     end
 
-    def query_url(query)
-      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?"
+    end
+
     def configure_ssl!(client)
       client.instance_eval {
         @ssl_context = OpenSSL::SSL::SSLContext.new
@@ -52,21 +52,25 @@ module Geocoder::Lookup
         raise_error(Geocoder::OverQueryLimitError) ||
           Geocoder.log(:warn, "#{name} API error: over query limit.")
       when "REQUEST_DENIED"
-        raise_error(Geocoder::RequestDenied) ||
-          Geocoder.log(:warn, "#{name} API error: request denied.")
+        raise_error(Geocoder::RequestDenied, doc['error_message']) ||
+          Geocoder.log(:warn, "#{name} API error: request denied (#{doc['error_message']}).")
       when "INVALID_REQUEST"
-        raise_error(Geocoder::InvalidRequest) ||
-          Geocoder.log(:warn, "#{name} API error: invalid request.")
+        raise_error(Geocoder::InvalidRequest, doc['error_message']) ||
+          Geocoder.log(:warn, "#{name} API error: invalid request (#{doc['error_message']}).")
       end
       return []
     end
 
     def query_url_google_params(query)
       params = {
-        (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
         :sensor => "false",
         :language => (query.language || configuration.language)
       }
+      if query.options[:google_place_id]
+        params[:place_id] = query.sanitized_text
+      else
+        params[(query.reverse_geocode? ? :latlng : :address)] = query.sanitized_text
+      end
       unless (bounds = query.options[:bounds]).nil?
         params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join('|')
       end