geocoder 1.2.6 → 1.8.2

data/lib/geocoder/lookups/ipstack.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipstack'
+
+module Geocoder::Lookup
+  class Ipstack < Base
+
+    ERROR_CODES = {
+      404 => Geocoder::InvalidRequest,
+      101 => Geocoder::InvalidApiKey,
+      102 => Geocoder::Error,
+      103 => Geocoder::InvalidRequest,
+      104 => Geocoder::OverQueryLimitError,
+      105 => Geocoder::RequestDenied,
+      301 => Geocoder::InvalidRequest,
+      302 => Geocoder::InvalidRequest,
+      303 => Geocoder::RequestDenied,
+    }
+    ERROR_CODES.default = Geocoder::Error
+
+    def name
+      "Ipstack"
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://#{host}/#{query.sanitized_text}?"
+    end
+
+    def query_url_params(query)
+      {
+        access_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['info']
+        raise_error(ERROR_CODES[code], msg ) || Geocoder.log(:warn, "Ipstack Geocoding API error: #{msg}")
+        return []
+      end
+      [doc]
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def host
+      configuration[:host] || "api.ipstack.com"
+    end
+  end
+end

data/lib/geocoder/lookups/latlon.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/latlon'
+
+module Geocoder::Lookup
+  class Latlon < Base
+
+    def name
+      "LatLon.io"
+    end
+
+    def required_api_key_parts
+      ["api_key"]
+    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?
+        [doc]
+      # The API returned a 404 response, which indicates no results found
+      elsif doc['error']['type'] == 'api_error'
+        []
+      elsif doc['error']['type'] == 'authentication_error'
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "LatLon.io service error: invalid API key.")
+      else
+        []
+      end
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        {
+          :token => configuration.api_key,
+          :lat => query.coordinates[0],
+          :lon => query.coordinates[1]
+        }.merge(super)
+      else
+        {
+          :token => configuration.api_key,
+          :address => query.sanitized_text
+        }.merge(super)
+      end
+    end
+
+  end
+end

data/lib/geocoder/lookups/location_iq.rb

@@ -0,0 +1,54 @@
+require 'geocoder/lookups/nominatim'
+require "geocoder/results/location_iq"
+
+module Geocoder::Lookup
+  class LocationIq < Nominatim
+    def name
+      "LocationIq"
+    end
+
+    def required_api_key_parts
+      ["api_key"]
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      "#{protocol}://#{configured_host}/v1/#{method}.php?"
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
+
+    def configured_host
+      configuration[:host] || "us1.locationiq.com"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if !doc.is_a?(Array)
+        case doc['error']
+        when "Invalid key"
+          raise_error(Geocoder::InvalidApiKey, doc['error'])
+        when "Key not active - Please write to contact@unwiredlabs.com"
+          raise_error(Geocoder::RequestDenied, doc['error'])
+        when "Rate Limited"
+          raise_error(Geocoder::OverQueryLimitError, doc['error'])
+        when "Unknown error - Please try again after some time"
+          raise_error(Geocoder::InvalidRequest, doc['error'])
+        end
+      end
+
+      doc.is_a?(Array) ? doc : [doc]
+    end
+  end
+end

data/lib/geocoder/lookups/mapbox.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/mapbox"
+
+module Geocoder::Lookup
+  class Mapbox < Base
+
+    def name
+      "Mapbox"
+    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']
+        sort_relevant_feature(data['features'])
+      elsif data['message'] =~ /Invalid\sToken/
+        raise_error(Geocoder::InvalidApiKey, data['message'])
+      else
+        []
+      end
+    end
+
+    def query_url_params(query)
+      {access_token: configuration.api_key}.merge(super(query))
+    end
+
+    def mapbox_search_term(query)
+      require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        "#{CGI.escape lon},#{CGI.escape lat}"
+      else
+        # 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
+
+    def dataset
+      configuration[:dataset] || "mapbox.places"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def sort_relevant_feature(features)
+      # Sort by descending relevance; Favor original order for equal relevance (eg occurs for reverse geocoding)
+      features.sort_by do |feature|
+        [feature["relevance"],-features.index(feature)]
+      end.reverse
+    end
+  end
+end

data/lib/geocoder/lookups/mapquest.rb

@@ -13,15 +13,13 @@ module Geocoder::Lookup
       ["key"]
     end
 
-    def query_url(query)
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
       domain = configuration[:open] ? "open" : "www"
-      version = configuration[:version] || 1
-      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v#{version}/#{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
@@ -45,13 +43,13 @@ module Geocoder::Lookup
       case doc['info']['statuscode']
       when 400 # Error with input
         raise_error(Geocoder::InvalidRequest, messages) ||
-          warn("Mapquest Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Mapquest Geocoding API error: #{messages}")
       when 403 # Key related error
         raise_error(Geocoder::InvalidApiKey, messages) ||
-          warn("Mapquest Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Mapquest Geocoding API error: #{messages}")
       when 500 # Unknown error
         raise_error(Geocoder::Error, messages) ||
-          warn("Mapquest Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Mapquest Geocoding API error: #{messages}")
       end
       []
     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,14 +57,14 @@ 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)
           return [doc]
         elsif doc.last == "INVALID_LICENSE_KEY"
-          raise_error(Geocoder::InvalidApiKey) || warn("Invalid MaxMind API key.")
+          raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid MaxMind API key.")
         end
       end
       return []

data/lib/geocoder/lookups/maxmind_geoip2.rb

@@ -0,0 +1,70 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind_geoip2'
+
+module Geocoder::Lookup
+  class MaxmindGeoip2 < Base
+
+    def name
+      "MaxMind GeoIP2"
+    end
+
+    # Maxmind's GeoIP2 Precision Services only supports HTTPS,
+    # otherwise a `404 Not Found` HTTP response will be returned
+    def supported_protocols
+      [:https]
+    end
+
+    def query_url(query)
+      "#{protocol}://geoip.maxmind.com/geoip/v2.1/#{configured_service!}/#{query.sanitized_text.strip}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    ##
+    # Return the name of the configured service, or raise an exception.
+    #
+    def configured_service!
+      if s = configuration[:service] and services.include?(s) and configuration[:basic_auth][:user] and configuration[:basic_auth][:password]
+        return s
+      else
+        raise(
+          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
+
+    def data_contains_error?(doc)
+      (["code", "error"] - doc.keys).empty?
+    end
+
+    ##
+    # Service names used in URL.
+    #
+    def services
+      [
+        :country,
+        :city,
+        :insights,
+      ]
+    end
+
+    def results(query)
+      # 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)
+          return [doc]
+        else
+          Geocoder.log(:warn, "MaxMind GeoIP2 Geocoding API error: #{doc['code']} (#{doc['error']}).")
+        end
+      end
+      return []
+    end
+  end
+end

data/lib/geocoder/lookups/maxmind_local.rb

@@ -30,13 +30,19 @@ 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)
-        result.nil? ? [] : [result.to_hash]
+        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
         q = "SELECT l.country, l.region, l.city, l.latitude, l.longitude
           FROM maxmind_geolite_city_location l WHERE l.loc_id = (SELECT b.loc_id FROM maxmind_geolite_city_blocks b
-          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num LIMIT 1)"
+          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num)"
         format_result(q, [:country_name, :region_name, :city_name, :latitude, :longitude])
       elsif configuration[:package] == :country
         addr = IPAddr.new(query.text).to_i
@@ -46,6 +52,13 @@ module Geocoder::Lookup
       end
     end
 
+    def encode_hash(hash, encoding = "UTF-8")
+      hash.inject({}) do |h,i|
+        h[i[0]] = i[1].is_a?(String) ? i[1].encode(encoding) : i[1]
+        h
+      end
+    end
+
     def format_result(query, attr_names)
       if r = ActiveRecord::Base.connection.execute(query).first
         r = r.values if r.is_a?(Hash) # some db adapters return Hash, some Array

data/lib/geocoder/lookups/melissa_street.rb

@@ -0,0 +1,41 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/melissa_street"
+
+module Geocoder::Lookup
+  class MelissaStreet < Base
+
+    def name
+      "MelissaStreet"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if doc["TransmissionResults"] == "GE05"
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "Melissa service error: invalid API key.")
+      end
+
+      return doc["Records"]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://address.melissadata.net/v3/WEB/GlobalAddress/doGlobalAddress?"
+    end
+
+    def query_url_params(query)
+      params = {
+        id: configuration.api_key,
+        format: "JSON",
+        a1: query.sanitized_text,
+        loc: query.options[:city],
+        admarea: query.options[:state],
+        postal: query.options[:postal],
+        ctry: query.options[:country]
+      }
+      params.merge(super)
+    end
+  end
+end

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

@@ -9,16 +9,28 @@ module Geocoder::Lookup
     end
 
     def map_link_url(coordinates)
-      "http://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
+      "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"
-      host = configuration[:host] || "nominatim.openstreetmap.org"
-      "#{protocol}://#{host}/#{method}?" + url_query_string(query)
+      "#{protocol}://#{configured_host}/#{method}?"
     end
 
-    private # ---------------------------------------------------------------
+    def configured_host
+      configuration[:host] || "nominatim.openstreetmap.org"
+    end
+
+    def use_ssl?
+      # nominatim.openstreetmap.org redirects HTTP requests to HTTPS
+      if configured_host == "nominatim.openstreetmap.org"
+        true
+      else
+        super
+      end
+    end
 
     def results(query)
       return [] unless doc = fetch_data(query)
@@ -27,7 +39,7 @@ module Geocoder::Lookup
 
     def parse_raw_data(raw_data)
       if raw_data.include?("Bandwidth limit exceeded")
-        raise_error(Geocoder::OverQueryLimitError) || warn("Over API query limit.")
+        raise_error(Geocoder::OverQueryLimitError) || Geocoder.log(:warn, "Over API query limit.")
       else
         super(raw_data)
       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)
@@ -26,16 +26,16 @@ module Geocoder::Lookup
       case doc['status']['code']
       when 400 # Error with input
         raise_error(Geocoder::InvalidRequest, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       when 403 # Key related error
         raise_error(Geocoder::InvalidApiKey, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       when 402 # Quata Exceeded
           raise_error(Geocoder::OverQueryLimitError, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       when 500 # Unknown error
         raise_error(Geocoder::Error, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       end
 
       return doc["results"]
@@ -44,9 +44,16 @@ module Geocoder::Lookup
     def query_url_params(query)
       params = {
         :q => query.sanitized_text,
+        :key => configuration.api_key,
         :language => (query.language || configuration.language)
       }.merge(super)
 
+      [:abbrv, :countrycode, :min_confidence, :no_dedupe, :no_annotations, :no_record, :limit].each do |option|
+        unless (option_value = query.options[option]).nil?
+          params[option] = option_value
+        end
+      end
+
       unless (bounds = query.options[:bounds]).nil?
         params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join(',')
       end

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