geocoder 1.4.9 → 1.6.7

data/lib/geocoder/lookups/ipinfo_io.rb

@@ -8,47 +8,29 @@ module Geocoder::Lookup
       "Ipinfo.io"
     end
 
-    def query_url(query)
-      if configuration.api_key
-        "#{protocol}://ipinfo.io/#{query.sanitized_text}/geo?" + url_query_string(query)
-      else
-        "#{protocol}://ipinfo.io/#{query.sanitized_text}/geo"
-      end
-    end
+    private # ---------------------------------------------------------------
 
-    # HTTPS available only for paid plans
-    def supported_protocols
-      if configuration.api_key
-        [:http, :https]
-      else
-        [:http]
-      end
+    def base_query_url(query)
+      url = "#{protocol}://ipinfo.io/#{query.sanitized_text}/geo"
+      url << "?" if configuration.api_key
+      url
     end
 
-    private # ---------------------------------------------------------------
-
     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?
-      if (doc = fetch_data(query)).nil? or doc['code'] == 401 or empty_result?(doc)
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
+
+      if !(doc = fetch_data(query)).is_a?(Hash) or doc['error']
         []
       else
         [doc]
       end
     end
 
-    def empty_result?(doc)
-      !doc.is_a?(Hash) or doc.keys == ["ip"]
-    end
-
     def reserved_result(ip)
       {
-        "ip"           => ip,
-        "city"         => "",
-        "region"       => "",
-        "country"      => "",
-        "loc"          => "0,0",
-        "postal"       => ""
+        "ip" => ip,
+        "bogon" => true
       }
     end
 

data/lib/geocoder/lookups/ipregistry.rb

@@ -0,0 +1,68 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipregistry'
+
+module Geocoder::Lookup
+  class Ipregistry < Base
+
+    ERROR_CODES = {
+      400 => Geocoder::InvalidRequest,
+      401 => Geocoder::InvalidRequest,
+      402 => Geocoder::OverQueryLimitError,
+      403 => Geocoder::InvalidApiKey,
+      451 => Geocoder::RequestDenied,
+      500 => Geocoder::Error
+    }
+    ERROR_CODES.default = Geocoder::Error
+
+    def name
+      "Ipregistry"
+    end
+
+    def supported_protocols
+      [:https, :http]
+    end
+
+    private
+
+    def base_query_url(query)
+      "#{protocol}://#{host}/#{query.sanitized_text}?"
+    end
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    def host
+      configuration[:host] || "api.ipregistry.co"
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
+
+    def results(query)
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
+
+      return [] unless (doc = fetch_data(query))
+
+      if (error = doc['error'])
+        code = error['code']
+        msg = error['message']
+        raise_error(ERROR_CODES[code], msg ) || Geocoder.log(:warn, "Ipregistry API error: #{msg}")
+        return []
+      end
+      [doc]
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+  end
+end

data/lib/geocoder/lookups/ipstack.rb

@@ -21,18 +21,21 @@ module Geocoder::Lookup
       "Ipstack"
     end
 
-    def query_url(query)
-      extra_params = url_query_string(query)
-      url = "#{protocol}://#{host}/#{query.sanitized_text}?access_key=#{api_key}"
-      url << "&#{extra_params}" unless extra_params.empty?
-      url
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://#{host}/#{query.sanitized_text}?"
     end
 
-    private
+    def query_url_params(query)
+      {
+        access_key: configuration.api_key
+      }.merge(super)
+    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?
 
       return [] unless doc = fetch_data(query)
 
@@ -56,9 +59,5 @@ module Geocoder::Lookup
     def host
       configuration[:host] || "api.ipstack.com"
     end
-
-    def api_key
-      configuration.api_key
-    end
   end
 end

data/lib/geocoder/lookups/latlon.rb

@@ -12,12 +12,12 @@ module Geocoder::Lookup
       ["api_key"]
     end
 
-    def query_url(query)
-      "#{protocol}://latlon.io/api/v1/#{'reverse_' if query.reverse_geocode?}geocode?#{url_query_string(query)}"
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://latlon.io/api/v1/#{'reverse_' if query.reverse_geocode?}geocode?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       if doc['error'].nil?
@@ -25,8 +25,7 @@ module Geocoder::Lookup
       # The API returned a 404 response, which indicates no results found
       elsif doc['error']['type'] == 'api_error'
         []
-      elsif
-        doc['error']['type'] == 'authentication_error'
+      elsif doc['error']['type'] == 'authentication_error'
         raise_error(Geocoder::InvalidApiKey) ||
           Geocoder.log(:warn, "LatLon.io service error: invalid API key.")
       else

data/lib/geocoder/lookups/location_iq.rb

@@ -10,13 +10,19 @@ module Geocoder::Lookup
     def required_api_key_parts
       ["api_key"]
     end
-    
-    def query_url(query)
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
       method = query.reverse_geocode? ? "reverse" : "search"
-      "#{protocol}://#{configured_host}/v1/#{method}.php?key=#{configuration.api_key}&" + url_query_string(query)
+      "#{protocol}://#{configured_host}/v1/#{method}.php?"
     end
 
-    private
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
 
     def configured_host
       configuration[:host] || "locationiq.org"

data/lib/geocoder/lookups/mapbox.rb

@@ -8,13 +8,12 @@ module Geocoder::Lookup
       "Mapbox"
     end
 
-    def query_url(query)
-      path = "#{mapbox_search_term(query)}.json?#{url_query_string(query)}"
-      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{path}"
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{mapbox_search_term(query)}.json?"
+    end
+
     def results(query)
       return [] unless data = fetch_data(query)
       if data['features']
@@ -36,7 +35,9 @@ module Geocoder::Lookup
         lat,lon = query.coordinates
         "#{CGI.escape lon},#{CGI.escape lat}"
       else
-        CGI.escape query.text.to_s
+        # truncate at first semicolon so Mapbox doesn't go into batch mode
+        # (see Github issue #1299)
+        CGI.escape query.text.to_s.split(';').first.to_s
       end
     end
 

data/lib/geocoder/lookups/mapquest.rb

@@ -13,14 +13,13 @@ module Geocoder::Lookup
       ["key"]
     end
 
-    def query_url(query)
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
       domain = configuration[:open] ? "open" : "www"
-      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
-      url + url_query_string(query)
+      "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
     end
 
-    private # ---------------------------------------------------------------
-
     def search_type(query)
       query.reverse_geocode? ? "reverse" : "address"
     end

data/lib/geocoder/lookups/maxmind.rb

@@ -9,12 +9,12 @@ module Geocoder::Lookup
       "MaxMind"
     end
 
-    def query_url(query)
-      "#{protocol}://geoip.maxmind.com/#{service_code}?" + url_query_string(query)
-    end
-
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://geoip.maxmind.com/#{service_code}?"
+    end
+
     ##
     # Return the name of the configured service, or raise an exception.
     #
@@ -57,8 +57,8 @@ module Geocoder::Lookup
     end
 
     def results(query)
-      # don't look up a loopback address, just return the stored result
-      return [reserved_result] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result] if query.internal_ip_address?
       doc = fetch_data(query)
       if doc and doc.is_a?(Array)
         if !data_contains_error?(doc)

data/lib/geocoder/lookups/maxmind_geoip2.rb

@@ -20,6 +20,10 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def cache_key(query)
+      query_url(query)
+    end
+
     ##
     # Return the name of the configured service, or raise an exception.
     #
@@ -28,11 +32,7 @@ module Geocoder::Lookup
         return s
       else
         raise(
-          Geocoder::ConfigurationError,
-          "When using MaxMind GeoIP2 you MUST specify a service name and basic_auth: " +
-          "Geocoder.configure(:maxmind_geoip2 => {:service => ...}, " +
-          ":basic_auth => {:user ..., :password => ...}), " +
-          "where service is one of: #{services.inspect}"
+          Geocoder::ConfigurationError, "When using MaxMind GeoIP2 you must specify a service and credentials: Geocoder.configure(maxmind_geoip2: {service: ..., basic_auth: {user: ..., password: ...}}), where service is one of: #{services.inspect}"
         )
       end
     end
@@ -53,8 +53,9 @@ module Geocoder::Lookup
     end
 
     def results(query)
-      # don't look up a loopback address
-      return [] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [] if query.internal_ip_address?
+
       doc = fetch_data(query)
       if doc
         if !data_contains_error?(doc)

data/lib/geocoder/lookups/maxmind_local.rb

@@ -30,7 +30,13 @@ module Geocoder::Lookup
     def results(query)
       if configuration[:file]
         geoip_class = RUBY_PLATFORM == "java" ? JGeoIP : GeoIP
-        result = geoip_class.new(configuration[:file]).city(query.to_s)
+        geoip_instance = geoip_class.new(configuration[:file])
+        result =
+          if configuration[:package] == :country
+            geoip_instance.country(query.to_s)
+          else
+            geoip_instance.city(query.to_s)
+          end
         result.nil? ? [] : [encode_hash(result.to_hash)]
       elsif configuration[:package] == :city
         addr = IPAddr.new(query.text).to_i

data/lib/geocoder/lookups/nationaal_georegister_nl.rb

@@ -0,0 +1,38 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/nationaal_georegister_nl"
+
+module Geocoder::Lookup
+  class NationaalGeoregisterNl < Base
+
+    def name
+      'Nationaal Georegister Nederland'
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      base_query_url(query) + hash_to_query(query_url_params(query))
+    end
+
+    def base_query_url(query)
+      "#{protocol}://geodata.nationaalgeoregister.nl/locatieserver/v3/free?"
+    end
+
+    def valid_response?(response)
+      json   = parse_json(response.body)
+      super(response) if json
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc['response']['docs']
+    end
+
+    def query_url_params(query)
+      {
+        fl: '*',
+        q:  query.text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/nominatim.rb

@@ -12,13 +12,13 @@ module Geocoder::Lookup
       "https://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
     end
 
-    def query_url(query)
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
       method = query.reverse_geocode? ? "reverse" : "search"
-      "#{protocol}://#{configured_host}/#{method}?" + url_query_string(query)
+      "#{protocol}://#{configured_host}/#{method}?"
     end
 
-    private # ---------------------------------------------------------------
-
     def configured_host
       configuration[:host] || "nominatim.openstreetmap.org"
     end

data/lib/geocoder/lookups/opencagedata.rb

@@ -8,15 +8,15 @@ module Geocoder::Lookup
       "OpenCageData"
     end
 
-    def query_url(query)
-      "#{protocol}://api.opencagedata.com/geocode/v1/json?key=#{configuration.api_key}&#{url_query_string(query)}"
-    end
-
     def required_api_key_parts
       ["key"]
     end
 
-    private
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.opencagedata.com/geocode/v1/json?"
+    end
 
     def results(query)
       return [] unless doc = fetch_data(query)
@@ -44,6 +44,7 @@ module Geocoder::Lookup
     def query_url_params(query)
       params = {
         :q => query.sanitized_text,
+        :key => configuration.api_key,
         :language => (query.language || configuration.language)
       }.merge(super)
 

data/lib/geocoder/lookups/osmnames.rb

@@ -0,0 +1,57 @@
+require 'cgi'
+require 'geocoder/lookups/base'
+require 'geocoder/results/osmnames'
+
+module Geocoder::Lookup
+  class Osmnames < Base
+
+    def name
+      'OSM Names'
+    end
+
+    def required_api_key_parts
+      configuration[:host] ? [] : ['key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private
+
+    def base_query_url(query)
+      "#{base_url(query)}/#{params_url(query)}.js?"
+    end
+
+    def base_url(query)
+      host = configuration[:host] || 'geocoder.tilehosting.com'
+      "#{protocol}://#{host}"
+    end
+
+    def params_url(query)
+      method, args = 'q', CGI.escape(query.sanitized_text)
+      method, args = 'r', query.coordinates.join('/') if query.reverse_geocode?
+      "#{country_limited(query)}#{method}/#{args}"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if (error = doc['message'])
+        raise_error(Geocoder::InvalidRequest, error) ||
+          Geocoder.log(:warn, "OSMNames Geocoding API error: #{error}")
+      else
+        return doc['results']
+      end
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
+
+    def country_limited(query)
+      "#{query.options[:country_code].downcase}/" if query.options[:country_code] && !query.reverse_geocode?
+    end
+  end
+end