geocoder 1.2.6 → 1.8.2

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

@@ -1,34 +1,50 @@
 require 'geocoder/lookups/base'
 require "geocoder/results/esri"
+require 'geocoder/esri_token'
 
 module Geocoder::Lookup
   class Esri < Base
-    
+
     def name
       "Esri"
     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)
-    end
+      def supported_protocols
+        [:https]
+      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?
-      end
-
       if (doc['error'].nil?)
+        if (!query.reverse_geocode?)
+          return [] if !doc['locations'] || doc['locations'].empty?
+        end
         return [ doc ]
       else
-        return []
+        case [ doc['error']['code'] ]
+        when [498]
+          raise_error(Geocoder::InvalidApiKey, doc['error']['message']) ||
+            Geocoder.log(:warn, "#{self.name} Geocoding API error: #{doc['error']['message']}")
+        when [ 403 ]
+          raise_error(Geocoder::RequestDenied, 'ESRI request denied') ||
+            Geocoder.log(:warn, "#{self.name} ESRI request denied: #{doc['error']['message']}")
+        when [ 500 ], [501]
+          raise_error(Geocoder::ServiceUnavailable, 'ESRI service unavailable') ||
+            Geocoder.log(:warn, "#{self.name} ESRI service error: #{doc['error']['message']}")
+        else
+          raise_error(Geocoder::Error, doc['error']['message']) ||
+            Geocoder.log(:warn, "#{self.name} Geocoding error: #{doc['error']['message']}")
+        end
       end
+      return []
     end
 
     def query_url_params(query)
@@ -41,8 +57,58 @@ module Geocoder::Lookup
       else
         params[:text] = query.sanitized_text
       end
+
+      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[:preferredLabelValues] = configuration[:preferred_label_values] if configuration[:preferred_label_values]
+
       params.merge(super)
     end
 
+    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?(token_instance)
+      !token_instance.nil? && token_instance.active?
+    end
+
+    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
   end
 end

data/lib/geocoder/lookups/freegeoip.rb

@@ -8,19 +8,34 @@ module Geocoder::Lookup
       "FreeGeoIP"
     end
 
-    def query_url(query)
-      "#{protocol}://#{host}/json/#{query.sanitized_text}"
+    def supported_protocols
+      if configuration[:host]
+        [:https]
+      else
+        # use https for default host
+        [:https]
+      end
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://#{host}/json/#{query.sanitized_text}?"
+    end
+
+    def query_url_params(query)
+      {
+        :apikey => configuration.api_key
+      }.merge(super)
+    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
@@ -31,8 +46,8 @@ module Geocoder::Lookup
         "city"         => "",
         "region_code"  => "",
         "region_name"  => "",
-        "metrocode"    => "",
-        "zipcode"      => "",
+        "metro_code"    => "",
+        "zip_code"      => "",
         "latitude"     => "0",
         "longitude"    => "0",
         "country_name" => "Reserved",
@@ -41,7 +56,7 @@ module Geocoder::Lookup
     end
 
     def host
-      configuration[:host] || "freegeoip.net"
+      configuration[:host] || "freegeoip.app"
     end
   end
 end

data/lib/geocoder/lookups/geoapify.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/geoapify'
+
+module Geocoder
+  module Lookup
+    # https://apidocs.geoapify.com/docs/geocoding/api
+    class Geoapify < Base
+      def name
+        'Geoapify'
+      end
+
+      def required_api_key_parts
+        ['api_key']
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def base_query_url(query)
+        method = if query.reverse_geocode?
+          'reverse'
+        elsif query.options[:autocomplete]
+          'autocomplete'
+        else
+          'search'
+        end
+        "https://api.geoapify.com/v1/geocode/#{method}?"
+      end
+
+      def results(query)
+        return [] unless (doc = fetch_data(query))
+
+        # The rest of the status codes should be already handled by the default
+        # functionality as the API returns correct HTTP response codes in most
+        # cases. There may be some unhandled cases still (such as over query
+        # limit reached) but there is not enough documentation to cover them.
+        case doc['statusCode']
+        when 500
+          raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, doc['message'])
+        end
+
+        return [] unless doc['type'] == 'FeatureCollection'
+        return [] unless doc['features'] || doc['features'].present?
+
+        doc['features']
+      end
+
+      def query_url_params(query)
+        lang = query.language || configuration.language
+        params = { apiKey: configuration.api_key, lang: lang, limit: query.options[:limit] }
+
+        if query.reverse_geocode?
+          params.merge!(query_url_params_reverse(query))
+        else
+          params.merge!(query_url_params_coordinates(query))
+        end
+
+        params.merge!(super)
+      end
+
+      def query_url_params_coordinates(query)
+        { text: query.sanitized_text }
+      end
+
+      def query_url_params_reverse(query)
+        {
+          lat: query.coordinates[0],
+          lon: query.coordinates[1]
+        }
+      end
+    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?
@@ -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/geocodio.rb

@@ -8,30 +8,30 @@ 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?
       
       if doc['error'] == 'Invalid API key'
         raise_error(Geocoder::InvalidApiKey) ||
-          warn("Geocodio service error: invalid API key.")
+          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']) ||
-          warn("Geocodio service error: #{doc['error']}.")
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
       else
         raise_error(Geocoder::InvalidRequest, doc['error']) ||
-          warn("Geocodio service error: #{doc['error']}.")
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
       end
       []
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1.6/#{path}?"
+    end
+
     def query_url_params(query)
       {
         :api_key => configuration.api_key,

data/lib/geocoder/lookups/geoip2.rb

@@ -4,6 +4,8 @@ require 'geocoder/results/geoip2'
 module Geocoder
   module Lookup
     class Geoip2 < Base
+      attr_reader :gem_name
+
       def initialize
         unless configuration[:file].nil?
           begin
@@ -12,6 +14,8 @@ module Geocoder
           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
@@ -26,13 +30,18 @@ module Geocoder
 
       private
 
+      def db_class
+        gem_name == 'hive_geoip2' ? Hive::GeoIP2 : MaxMindDB
+      end
+
       def results(query)
         return [] unless configuration[:file]
-        if @gem_name == 'hive_geoip2'
-          result = Hive::GeoIP2.lookup(query.to_s, configuration[:file].to_s)
-        else
-          result = MaxMindDB.new(configuration[:file].to_s).lookup(query.to_s)
+
+        if @mmdb.respond_to?(:local_ip_alias) && !configuration[:local_ip_alias].nil?
+          @mmdb.local_ip_alias = configuration[:local_ip_alias]
         end
+
+        result = @mmdb.lookup(query.to_s)
         result.nil? ? [] : [result]
       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
+
+      private # ---------------------------------------------------------------
+
+      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
+        "#{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) ||
+              Geocoder.log(:warn, "Geportail.lu Geocoding API error")
+        end
+        result
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/google.rb

@@ -12,40 +12,70 @@ module Geocoder::Lookup
       "http://maps.google.com/maps?q=#{coordinates.join(',')}"
     end
 
-    def query_url(query)
-      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
+    def supported_protocols
+      # Google requires HTTPS if an API key is used.
+      if configuration.api_key
+        [:https]
+      else
+        [:http, :https]
+      end
     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
+        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
 
+    def result_root_attr
+      'results'
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
-      case doc['status']; when "OK" # OK status implies >0 results
-        return doc['results']
+      case doc['status']
+      when "OK" # OK status implies >0 results
+        return doc[result_root_attr]
       when "OVER_QUERY_LIMIT"
         raise_error(Geocoder::OverQueryLimitError) ||
-          warn("Google Geocoding API error: over query limit.")
+          Geocoder.log(:warn, "#{name} API error: over query limit.")
       when "REQUEST_DENIED"
-        raise_error(Geocoder::RequestDenied) ||
-          warn("Google Geocoding 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) ||
-          warn("Google Geocoding 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
@@ -55,6 +85,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
 

data/lib/geocoder/lookups/google_places_details.rb

@@ -12,36 +12,50 @@ module Geocoder
         ["key"]
       end
 
-      def use_ssl?
-        true
+      def supported_protocols
+        [:https]
       end
 
-      def query_url(query)
-        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?#{url_query_string(query)}"
+      private
+
+      def base_query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?"
       end
 
-      private
+      def result_root_attr
+        'result'
+      end
 
       def results(query)
-        return [] unless doc = fetch_data(query)
-
-        case doc["status"]
-        when "OK"
-          return [doc["result"]]
-        when "OVER_QUERY_LIMIT"
-          raise_error(Geocoder::OverQueryLimitError) || warn("Google Places Details API error: over query limit.")
-        when "REQUEST_DENIED"
-          raise_error(Geocoder::RequestDenied) || warn("Google Places Details API error: request denied.")
-        when "INVALID_REQUEST"
-          raise_error(Geocoder::InvalidRequest) || warn("Google Places Details API error: invalid request.")
+        result = super(query)
+        return [result] unless result.is_a? Array
+
+        result
+      end
+
+      def fields(query)
+        if query.options.has_key?(:fields)
+          return format_fields(query.options[:fields])
+        end
+
+        if configuration.has_key?(:fields)
+          return format_fields(configuration[:fields])
         end
 
-        []
+        nil  # use Google Places defaults
+      end
+
+      def format_fields(*fields)
+        flattened = fields.flatten.compact
+        return if flattened.empty?
+
+        flattened.join(',')
       end
 
       def query_url_google_params(query)
         {
           placeid: query.text,
+          fields: fields(query),
           language: query.language || configuration.language
         }
       end