geocoder 1.2.6 → 1.8.2

data/lib/geocoder/lookups/abstract_api.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/abstract_api'
+
+module Geocoder::Lookup
+  class AbstractApi < Base
+
+    def name
+      "Abstract API"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipgeolocation.abstractapi.com/v1/?"
+    end
+
+    def query_url_params(query)
+      params = {api_key: configuration.api_key}
+
+      ip_address = query.sanitized_text
+      if ip_address.is_a?(String) && ip_address.length > 0
+        params[:ip_address] = ip_address
+      end
+
+      params.merge(super)
+    end
+
+    def results(query, reverse = false)
+      if doc = fetch_data(query)
+        [doc]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/amap.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/amap"
+
+module Geocoder::Lookup
+  class Amap < Base
+
+    def name
+      "AMap"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    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']]
+      when ['1', 'OK']
+        return doc['regeocodes'] unless doc['regeocodes'].blank?
+        return [doc['regeocode']] unless doc['regeocode'].blank?
+        return doc['geocodes'] unless doc['geocodes'].blank?
+      when ['0', 'INVALID_USER_KEY']
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: invalid api key.")
+      else
+        raise_error(Geocoder::Error, "server error.") ||
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: server error - [#{doc['info']}]")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      params = {
+        :key => configuration.api_key,
+        :output => "json"
+      }
+      if query.reverse_geocode?
+        params[:location] = revert_coordinates(query.text)
+        params[:extensions] = "all"
+        params[:coordsys] = "gps"
+      else
+        params[:address] = query.sanitized_text
+      end
+      params.merge(super)
+    end
+
+    def revert_coordinates(text)
+      [text[1],text[0]].join(",")
+    end
+
+  end
+end

data/lib/geocoder/lookups/amazon_location_service.rb

@@ -0,0 +1,55 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/amazon_location_service'
+
+module Geocoder::Lookup
+  class AmazonLocationService < Base
+    def results(query)
+      params = query.options.dup
+
+      # index_name is required
+      # Aws::ParamValidator raises ArgumentError on missing required keys
+      params.merge!(index_name: configuration[:index_name])
+
+      # Aws::ParamValidator raises ArgumentError on unexpected keys
+      params.delete(:lookup) 
+      
+      resp = if query.reverse_geocode?
+        client.search_place_index_for_position(params.merge(position: query.coordinates.reverse))
+      else
+        client.search_place_index_for_text(params.merge(text: query.text))
+      end
+      
+      resp.results.map(&:place)
+    end
+
+    private
+
+    def client
+      return @client if @client
+      require_sdk
+      keys = configuration.api_key
+      if keys
+        @client = Aws::LocationService::Client.new(**{
+          region: keys[:region],
+          access_key_id: keys[:access_key_id],
+          secret_access_key: keys[:secret_access_key]
+        }.compact)
+      else
+        @client = Aws::LocationService::Client.new
+      end
+    end
+
+    def require_sdk
+      begin
+        require 'aws-sdk-locationservice'
+      rescue LoadError
+        raise_error(Geocoder::ConfigurationError) ||
+          Geocoder.log(
+            :error,
+            "Couldn't load the Amazon Location Service SDK. " +
+            "Install it with: gem install aws-sdk-locationservice -v '~> 1.4'"
+          )
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/baidu.rb

@@ -12,32 +12,41 @@ module Geocoder::Lookup
       ["key"]
     end
 
-    def query_url(query)
-      "http://api.map.baidu.com/geocoder/v2/?" + url_query_string(query)
+    # HTTP only
+    def supported_protocols
+      [:http]
     end
 
     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.") ||
-          warn("Baidu Geocoding API error: server error.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: server error.")
       when 2
         raise_error(Geocoder::InvalidRequest, "invalid request.") ||
-          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") ||
-          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") ||
-          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.") ||
-          warn("Baidu Geocoding API error: over query limit.")
+          Geocoder.log(:warn, "#{name} Geocoding API error: over query limit.")
       end
       return []
     end
@@ -52,4 +61,3 @@ module Geocoder::Lookup
 
   end
 end
-

data/lib/geocoder/lookups/baidu_ip.rb

@@ -1,45 +1,21 @@
-require 'geocoder/lookups/base'
+require 'geocoder/lookups/baidu'
 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
+    private # ---------------------------------------------------------------
 
-    def query_url(query)
-      "http://api.map.baidu.com/location/ip?" + url_query_string(query)
+    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.") ||
-          warn("Baidu IP Geocoding API error: server error.")
-      when 2
-        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
-          warn("Baidu IP Geocoding API error: invalid request.")
-      when 5
-        raise_error(Geocoder::InvalidApiKey, "invalid api key.") ||
-          warn("Baidu IP Geocoding API error: invalid api key.")
-      when 101, 102, 200..299
-        raise_error(Geocoder::RequestDenied, "request denied.") ||
-          warn("Baidu IP Geocoding API error: request denied.")
-      when 300..399
-        raise_error(Geocoder::OverQueryLimitError, "over query limit") ||
-          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

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/ban_data_gouv_fr'
+
+module Geocoder::Lookup
+  class BanDataGouvFr < Base
+
+    def name
+      "Base Adresse Nationale Française"
+    end
+
+    def map_link_url(coordinates)
+      "https://www.openstreetmap.org/#map=19/#{coordinates.join('/')}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      "#{protocol}://api-adresse.data.gouv.fr/#{method}/?"
+    end
+
+    def any_result?(doc)
+      doc['features'] and doc['features'].any?
+    end
+
+    def results(query)
+      if doc = fetch_data(query) and any_result?(doc)
+        [doc]
+      else
+        []
+      end
+    end
+
+    #### PARAMS ####
+
+    def query_url_params(query)
+      query_ban_datagouv_fr_params(query).merge(super)
+    end
+
+    def query_ban_datagouv_fr_params(query)
+      query.reverse_geocode? ? reverse_geocode_ban_fr_params(query) : search_geocode_ban_fr_params(query)
+    end
+
+    #### SEARCH GEOCODING PARAMS ####
+    #
+    #  :q             =>    required, full text search param)
+
+    #  :limit         =>    force limit number of results returned by raw API
+    #                       (default = 5) note : only first result is taken
+    #                       in account in geocoder
+    #
+    #  :autocomplete  =>    pass 0 to disable autocomplete treatment of :q
+    #                       (default = 1)
+    #
+    #  :lat           =>    force filter results around specific lat/lon
+    #
+    #  :lon           =>    force filter results around specific lat/lon
+    #
+    #  :type          =>    force filter the returned result type
+    #                       (check results for a list of accepted types)
+    #
+    #  :postcode      =>    force filter results on a specific city post code
+    #
+    #  :citycode      =>    force filter results on a specific city UUID INSEE code
+    #
+    #  For up to date doc (in french only) : https://adresse.data.gouv.fr/api/
+    #
+    def search_geocode_ban_fr_params(query)
+      params = {
+        q: query.sanitized_text
+      }
+      unless (limit = query.options[:limit]).nil? || !limit_param_is_valid?(limit)
+        params[:limit] = limit.to_i
+      end
+      unless (autocomplete = query.options[:autocomplete]).nil? || !autocomplete_param_is_valid?(autocomplete)
+        params[:autocomplete] = autocomplete.to_s
+      end
+      unless (type = query.options[:type]).nil? || !type_param_is_valid?(type)
+        params[:type] = type.downcase
+      end
+      unless (postcode = query.options[:postcode]).nil? || !code_param_is_valid?(postcode)
+        params[:postcode] = postcode.to_s
+      end
+      unless (citycode = query.options[:citycode]).nil? || !code_param_is_valid?(citycode)
+        params[:citycode] = citycode.to_s
+      end
+      unless (lat = query.options[:lat]).nil? || !latitude_is_valid?(lat)
+        params[:lat] = lat
+      end
+      unless (lon = query.options[:lon]).nil? || !longitude_is_valid?(lon)
+        params[:lon] = lon
+      end
+      params
+    end
+
+    #### REVERSE GEOCODING PARAMS ####
+    #
+    #  :lat           =>    required
+    #
+    #  :lon           =>    required
+    #
+    #  :type          =>    force returned results type
+    #                       (check results for a list of accepted types)
+    #
+    def reverse_geocode_ban_fr_params(query)
+      lat_lon = query.coordinates
+      params = {
+          lat: lat_lon.first,
+          lon: lat_lon.last
+      }
+      unless (type = query.options[:type]).nil? || !type_param_is_valid?(type)
+        params[:type] = type.downcase
+      end
+      params
+    end
+
+    def limit_param_is_valid?(param)
+      param.to_i.positive?
+    end
+
+    def autocomplete_param_is_valid?(param)
+      [0,1].include?(param.to_i)
+    end
+
+    def type_param_is_valid?(param)
+      %w(housenumber street locality municipality).include?(param.downcase)
+    end
+
+    def code_param_is_valid?(param)
+      (1..99999).include?(param.to_i)
+    end
+
+    def latitude_is_valid?(param)
+      param.to_f <= 90 && param.to_f >= -90
+    end
+
+    def longitude_is_valid?(param)
+      param.to_f <= 180 && param.to_f >= -180
+    end
+  end
+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
 
       ##
@@ -81,13 +84,31 @@ module Geocoder
       #
       def cache
         if @cache.nil? and store = configuration.cache
-          @cache = Cache.new(store, configuration.cache_prefix)
+          cache_options = configuration.cache_options
+          @cache = Cache.new(store, cache_options)
         end
         @cache
       end
 
+      ##
+      # Array containing the protocols supported by the api.
+      # Should be set to [:http] if only HTTP is supported
+      # or [:https] if only HTTPS is supported.
+      #
+      def supported_protocols
+        [:http, :https]
+      end
+
       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.
       #
@@ -99,7 +120,6 @@ module Geocoder
       # Object used to make HTTP requests.
       #
       def http_client
-        protocol = "http#{'s' if use_ssl?}"
         proxy_name = "#{protocol}_proxy"
         if proxy = configuration.send(proxy_name)
           proxy_url = !!(proxy =~ /^#{protocol}/) ? proxy : protocol + '://' + proxy
@@ -139,7 +159,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
 
       ##
@@ -168,12 +195,14 @@ module Geocoder
       def fetch_data(query)
         parse_raw_data fetch_raw_data(query)
       rescue SocketError => err
-        raise_error(err) or warn "Geocoding API connection cannot be established."
+        raise_error(err) or Geocoder.log(:warn, "Geocoding API connection cannot be established.")
       rescue Errno::ECONNREFUSED => err
-        raise_error(err) or warn "Geocoding API connection refused."
-      rescue TimeoutError => err
-        raise_error(err) or warn "Geocoding API not responding fast enough " +
-          "(use Geocoder.configure(:timeout => ...) to set limit)."
+        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).")
       end
 
       def parse_json(data)
@@ -182,6 +211,11 @@ module Geocoder
         else
           JSON.parse(data)
         end
+      rescue
+        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
 
       ##
@@ -189,8 +223,6 @@ module Geocoder
       #
       def parse_raw_data(raw_data)
         parse_json(raw_data)
-      rescue
-        warn "Geocoding API's response was not valid JSON."
       end
 
       ##
@@ -242,16 +274,19 @@ module Geocoder
       def check_response_for_errors!(response)
         if response.code.to_i == 400
           raise_error(Geocoder::InvalidRequest) ||
-            warn("Geocoding API error: 400 Bad Request")
+            Geocoder.log(:warn, "Geocoding API error: 400 Bad Request")
         elsif response.code.to_i == 401
           raise_error(Geocoder::RequestDenied) ||
-            warn("Geocoding API error: 401 Unauthorized")
+            Geocoder.log(:warn, "Geocoding API error: 401 Unauthorized")
         elsif response.code.to_i == 402
           raise_error(Geocoder::OverQueryLimitError) ||
-            warn("Geocoding API error: 402 Payment Required")
+            Geocoder.log(:warn, "Geocoding API error: 402 Payment Required")
         elsif response.code.to_i == 429
           raise_error(Geocoder::OverQueryLimitError) ||
-            warn("Geocoding API error: 429 Too Many Requests")
+            Geocoder.log(:warn, "Geocoding API error: 429 Too Many Requests")
+        elsif response.code.to_i == 503
+          raise_error(Geocoder::ServiceUnavailable) ||
+            Geocoder.log(:warn, "Geocoding API error: 503 Service Unavailable")
         end
       end
 
@@ -260,23 +295,37 @@ module Geocoder
       # return the response object.
       #
       def make_api_request(query)
-        timeout(configuration.timeout) do
-          uri = URI.parse(query_url(query))
-          args = [uri.host, uri.port]
-          args = args.push(uri.user, uri.password) unless uri.user.nil? or uri.password.nil?
-          opts = {}
-          opts[:use_ssl] = use_ssl?
-
-          http_client.start(*args, opts) do |client|
-            client.get(uri.request_uri, configuration.http_headers)
+        uri = URI.parse(query_url(query))
+        Geocoder.log(:debug, "Geocoder: HTTP request being made for #{uri.to_s}")
+        http_client.start(uri.host, uri.port, use_ssl: use_ssl?, open_timeout: configuration.timeout, read_timeout: configuration.timeout) do |client|
+          configure_ssl!(client) if use_ssl?
+          req = Net::HTTP::Get.new(uri.request_uri, configuration.http_headers)
+          if configuration.basic_auth[:user] and configuration.basic_auth[:password]
+            req.basic_auth(
+              configuration.basic_auth[:user],
+              configuration.basic_auth[:password]
+            )
           end
+          client.request(req)
         end
+      rescue Timeout::Error
+        raise Geocoder::LookupTimeout
+      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ENETUNREACH, Errno::ECONNRESET
+        raise Geocoder::NetworkError
       end
 
       def use_ssl?
-        configuration.use_https
+        if supported_protocols == [:https]
+          true
+        elsif supported_protocols == [:http]
+          false
+        else
+          configuration.use_https
+        end
       end
 
+      def configure_ssl!(client); end
+
       def check_api_key_configuration!(query)
         key_parts = query.lookup.required_api_key_parts
         if key_parts.size > Array(configuration.api_key).size

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
 
@@ -43,17 +39,44 @@ module Geocoder::Lookup
       if doc['statusCode'] == 200
         return doc['resourceSets'].first['estimatedTotal'] > 0 ? doc['resourceSets'].first['resources'] : []
       elsif doc['statusCode'] == 401 and doc["authenticationResultCode"] == "InvalidCredentials"
-        raise_error(Geocoder::InvalidApiKey) || warn("Invalid Bing API key.")
+        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
-        warn "Bing Geocoding API error: #{doc['statusCode']} (#{doc['statusDescription']})."
+        Geocoder.log(:warn, "Bing Geocoding API error: #{doc['statusCode']} (#{doc['statusDescription']}).")
       end
       return []
     end
 
     def query_url_params(query)
       {
-        key: configuration.api_key
+        key: configuration.api_key,
+        culture: (query.language || configuration.language)
       }.merge(super)
     end
+
+    def check_response_for_errors!(response)
+      super
+      if server_overloaded?(response)
+        raise_error(Geocoder::ServiceUnavailable) ||
+          Geocoder.log(:warn, "Bing Geocoding API error: Service Unavailable")
+      end
+    end
+
+    def valid_response?(response)
+      super(response) and not server_overloaded?(response)
+    end
+
+    def server_overloaded?(response)
+      # Occasionally, the servers processing service requests can be overloaded,
+      # and you may receive some responses that contain no results for queries that
+      # you would normally receive a result. To identify this situation,
+      # check the HTTP headers of the response. If the HTTP header X-MS-BM-WS-INFO is set to 1,
+      # it is best to wait a few seconds and try again.
+      response['x-ms-bm-ws-info'].to_i == 1
+    end
   end
 end