geocoder 1.1.9 → 1.3.7

data/lib/geocoder/lookups/baidu_ip.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/baidu_ip'
+
+module Geocoder::Lookup
+  class BaiduIp < Base
+
+    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
+
+    # HTTP only
+    def supported_protocols
+      [:http]
+    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 []
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :ak => configuration.api_key,
+        :coor => "bd09ll"
+      }.merge(super)
+    end
+
+  end
+end

data/lib/geocoder/lookups/base.rb

@@ -15,6 +15,9 @@ module Geocoder
   module Lookup
 
     class Base
+      def initialize
+        @cache = nil
+      end
 
       ##
       # Human-readable name of the geocoding API.
@@ -83,6 +86,15 @@ module Geocoder
         @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 # -------------------------------------------------------------
 
       ##
@@ -96,7 +108,6 @@ module Geocoder
       # Object used to make HTTP requests.
       #
       def http_client
-        protocol = "http#{'s' if configuration.use_https}"
         proxy_name = "#{protocol}_proxy"
         if proxy = configuration.send(proxy_name)
           proxy_url = !!(proxy =~ /^#{protocol}/) ? proxy : protocol + '://' + proxy
@@ -165,10 +176,12 @@ 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."
-      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 cannot be established.")
+      rescue Errno::ECONNREFUSED => err
+        raise_error(err) or Geocoder.log(:warn, "Geocoding API connection refused.")
+      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)
@@ -177,6 +190,8 @@ module Geocoder
         else
           JSON.parse(data)
         end
+      rescue
+        raise_error(ResponseParseError.new(data)) or Geocoder.log(:warn, "Geocoding API's response was not valid JSON: #{data}")
       end
 
       ##
@@ -184,8 +199,6 @@ module Geocoder
       #
       def parse_raw_data(raw_data)
         parse_json(raw_data)
-      rescue
-        warn "Geocoding API's response was not valid JSON."
       end
 
       ##
@@ -193,7 +206,7 @@ module Geocoder
       # Set in configuration but not available for every service.
       #
       def protocol
-        "http" + (configuration.use_https ? "s" : "")
+        "http" + (use_ssl? ? "s" : "")
       end
 
       def valid_response?(response)
@@ -211,7 +224,21 @@ module Geocoder
         else
           check_api_key_configuration!(query)
           response = make_api_request(query)
+          check_response_for_errors!(response)
           body = response.body
+
+          # apply the charset from the Content-Type header, if possible
+          ct = response['content-type']
+
+          if ct && ct['charset']
+            charset = ct.split(';').select do |s|
+              s['charset']
+            end.first.to_s.split('=')
+            if charset.length == 2
+              body.force_encoding(charset.last) rescue ArgumentError
+            end
+          end
+
           if cache and valid_response?(response)
             cache[key] = body
           end
@@ -220,26 +247,61 @@ module Geocoder
         body
       end
 
+      def check_response_for_errors!(response)
+        if response.code.to_i == 400
+          raise_error(Geocoder::InvalidRequest) ||
+            Geocoder.log(:warn, "Geocoding API error: 400 Bad Request")
+        elsif response.code.to_i == 401
+          raise_error(Geocoder::RequestDenied) ||
+            Geocoder.log(:warn, "Geocoding API error: 401 Unauthorized")
+        elsif response.code.to_i == 402
+          raise_error(Geocoder::OverQueryLimitError) ||
+            Geocoder.log(:warn, "Geocoding API error: 402 Payment Required")
+        elsif response.code.to_i == 429
+          raise_error(Geocoder::OverQueryLimitError) ||
+            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
+
       ##
       # Make an HTTP(S) request to a geocoding API and
       # return the response object.
       #
       def make_api_request(query)
-        timeout(configuration.timeout) do
-          uri = URI.parse(query_url(query))
-          # client = http_client.new(uri.host, uri.port)
-          # client.use_ssl = true if configuration.use_https
-          # client.get(uri.request_uri, configuration.http_headers)
-
-          http_client.start(uri.host, uri.port) do |client|
-            client.use_ssl = true if configuration.use_https
-            req = Net::HTTP::Get.new(uri.request_uri, configuration.http_headers)
-            req.basic_auth(uri.user, uri.password) if uri.user and uri.password
-            client.request(req)
+        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
+        raise Geocoder::NetworkError
+      end
+
+      def use_ssl?
+        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

@@ -17,31 +17,64 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{protocol}://dev.virtualearth.net/REST/v1/Locations" +
-        (query.reverse_geocode? ? "/#{query.sanitized_text}?" : "?") +
-        url_query_string(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?
+        if r = query.options[:region]
+          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)}?"
+      end
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
 
       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.")
       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,
-        :query => query.reverse_geocode? ? nil : query.sanitized_text
+        key: configuration.api_key
       }.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

data/lib/geocoder/lookups/esri.rb

@@ -1,5 +1,6 @@
 require 'geocoder/lookups/base'
 require "geocoder/results/esri"
+require 'geocoder/esri_token'
 
 module Geocoder::Lookup
   class Esri < Base
@@ -9,19 +10,21 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      search_keyword = query.reverse_geocode? ? "reverseGeocode" : "find"
-
-      "#{protocol}://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/#{search_keyword}?" +
-        url_query_string(query)
+      base_query_url(query) + url_query_string(query)
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      action = query.reverse_geocode? ? "reverseGeocode" : "find"
+      "#{protocol}://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/#{action}?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
 
       if (!query.reverse_geocode?)
-        return [] if doc['locations'].empty?
+        return [] if !doc['locations'] || doc['locations'].empty?
       end
 
       if (doc['error'].nil?)
@@ -31,6 +34,17 @@ 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",
@@ -41,8 +55,31 @@ module Geocoder::Lookup
       else
         params[:text] = query.sanitized_text
       end
+      params[:token] = token
+      params[:forStorage] = configuration[:for_storage] if configuration[:for_storage]
+      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?
+    end
+
+    def valid_token_configured?
+      !configuration[:token].nil? and configuration[:token].active?
+    end
+
+    def create_and_save_token!
+      save_token!(create_token)
+    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,13 @@ module Geocoder::Lookup
     def name
       "FreeGeoIP"
     end
+    
+    def supported_protocols
+      [:http]
+    end
 
     def query_url(query)
-      "#{protocol}://freegeoip.net/json/#{query.sanitized_text}"
+      "#{protocol}://#{host}/json/#{query.sanitized_text}"
     end
 
     private # ---------------------------------------------------------------
@@ -39,5 +43,9 @@ module Geocoder::Lookup
         "country_code" => "RD"
       }
     end
+
+    def host
+      configuration[:host] || "freegeoip.io"
+    end
   end
 end

data/lib/geocoder/lookups/geocoder_ca.rb

@@ -21,7 +21,7 @@ module Geocoder::Lookup
       elsif doc['error']['code'] == "005"
         # "Postal Code is not in the proper Format" => no results, just shut up
       else
-        warn "Geocoder.ca service error: #{doc['error']['code']} (#{doc['error']['description']})."
+        Geocoder.log(:warn, "Geocoder.ca service error: #{doc['error']['code']} (#{doc['error']['description']}).")
       end
       return []
     end
@@ -51,4 +51,3 @@ module Geocoder::Lookup
     end
   end
 end
-

data/lib/geocoder/lookups/geocoder_us.rb

@@ -8,11 +8,15 @@ module Geocoder::Lookup
       "Geocoder.us"
     end
 
+      def supported_protocols
+        [:http]
+      end
+
     def query_url(query)
       if configuration.api_key
-        "http://#{configuration.api_key}@geocoder.us/member/service/csv/geocode?" + url_query_string(query)
+        "#{protocol}://#{configuration.api_key}@geocoder.us/member/service/csv/geocode?" + url_query_string(query)
       else
-        "http://geocoder.us/service/csv/geocode?" + url_query_string(query)
+        "#{protocol}://geocoder.us/service/csv/geocode?" + url_query_string(query)
       end
     end
 

data/lib/geocoder/lookups/geocodio.rb

@@ -0,0 +1,42 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocodio"
+
+module Geocoder::Lookup
+  class Geocodio < Base
+
+    def name
+      "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?
+      
+      if doc['error'] == 'Invalid API key'
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "Geocodio service error: invalid API key.")
+      elsif doc['error'].match(/You have reached your daily maximum/)
+        raise_error(Geocoder::OverQueryLimitError, doc['error']) ||
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
+      else
+        raise_error(Geocoder::InvalidRequest, doc['error']) ||
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
+      end
+      []
+    end
+
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      {
+        :api_key => configuration.api_key,
+        :q => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/geoip2.rb

@@ -0,0 +1,45 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/geoip2'
+
+module Geocoder
+  module Lookup
+    class Geoip2 < Base
+      attr_reader :gem_name
+
+      def initialize
+        unless configuration[:file].nil?
+          begin
+            @gem_name = configuration[:lib] || 'maxminddb'
+            require @gem_name
+          rescue LoadError
+            raise "Could not load Maxmind DB dependency. To use the GeoIP2 lookup you must add the #{@gem_name} gem to your Gemfile or have it installed in your system."
+          end
+
+          @mmdb = db_class.new(configuration[:file].to_s)
+        end
+        super
+      end
+
+      def name
+        'GeoIP2'
+      end
+
+      def required_api_key_parts
+        []
+      end
+
+      private
+
+      def db_class
+        gem_name == 'hive_geoip2' ? Hive::GeoIP2 : MaxMindDB
+      end
+
+      def results(query)
+        return [] unless configuration[:file]
+
+        result = @mmdb.lookup(query.to_s)
+        result.nil? ? [] : [result]
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/geoportail_lu.rb

@@ -0,0 +1,65 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geoportail_lu"
+
+module Geocoder
+  module Lookup
+    class GeoportailLu < Base
+
+      def name
+        "Geoportail.lu"
+      end
+
+      def query_url(query)
+        url_base_path(query) + url_query_string(query)
+      end
+
+      private
+
+      def url_base_path(query)
+        query.reverse_geocode? ? reverse_geocode_url_base_path : search_url_base_path
+      end
+
+      def search_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/search?"
+      end
+
+      def reverse_geocode_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/reverseGeocode?"
+      end
+
+      def query_url_geoportail_lu_params(query)
+        query.reverse_geocode? ? reverse_geocode_params(query) : search_params(query)
+      end
+
+      def search_params(query)
+        {
+            queryString: query.sanitized_text
+        }
+      end
+
+      def reverse_geocode_params(query)
+        lat_lon = query.coordinates
+        {
+            lat: lat_lon.first,
+            lon: lat_lon.last
+        }
+      end
+
+      def query_url_params(query)
+        query_url_geoportail_lu_params(query).merge(super)
+      end
+
+      def results(query)
+        return [] unless doc = fetch_data(query)
+        if doc['success'] == true
+          result = doc['results']
+        else
+          result = []
+          raise_error(Geocoder::Error) ||
+              warn("Geportail.lu Geocoding API error")
+        end
+        result
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/google.rb

@@ -12,14 +12,35 @@ module Geocoder::Lookup
       "http://maps.google.com/maps?q=#{coordinates.join(',')}"
     end
 
+    def supported_protocols
+      # Google requires HTTPS if an API key is used.
+      if configuration.api_key
+        [:https]
+      else
+        [:http, :https]
+      end
+    end
+
     def query_url(query)
       "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
     end
 
     private # ---------------------------------------------------------------
 
+    def configure_ssl!(client)
+      client.instance_eval {
+        @ssl_context = OpenSSL::SSL::SSLContext.new
+        options = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
+        if OpenSSL::SSL.const_defined?('OP_NO_COMPRESSION')
+          options |= OpenSSL::SSL::OP_NO_COMPRESSION
+        end
+        @ssl_context.set_params({options: options})
+      }
+    end
+
     def valid_response?(response)
-      status = parse_json(response.body)["status"]
+      json = parse_json(response.body)
+      status = json["status"] if json
       super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
     end
 
@@ -29,13 +50,13 @@ module Geocoder::Lookup
         return doc['results']
       when "OVER_QUERY_LIMIT"
         raise_error(Geocoder::OverQueryLimitError) ||
-          warn("Google Geocoding API error: over query limit.")
+          Geocoder.log(:warn, "Google Geocoding API error: over query limit.")
       when "REQUEST_DENIED"
         raise_error(Geocoder::RequestDenied) ||
-          warn("Google Geocoding API error: request denied.")
+          Geocoder.log(:warn, "Google Geocoding API error: request denied.")
       when "INVALID_REQUEST"
         raise_error(Geocoder::InvalidRequest) ||
-          warn("Google Geocoding API error: invalid request.")
+          Geocoder.log(:warn, "Google Geocoding API error: invalid request.")
       end
       return []
     end
@@ -44,7 +65,7 @@ module Geocoder::Lookup
       params = {
         (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
         :sensor => "false",
-        :language => configuration.language
+        :language => (query.language || configuration.language)
       }
       unless (bounds = query.options[:bounds]).nil?
         params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join('|')
@@ -55,6 +76,9 @@ module Geocoder::Lookup
       unless (components = query.options[:components]).nil?
         params[:components] = components.is_a?(Array) ? components.join("|") : components
       end
+      unless (result_type = query.options[:result_type]).nil?
+        params[:result_type] = result_type.is_a?(Array) ? result_type.join("|") : result_type
+      end
       params
     end