geocoder 1.2.6 → 1.6.1

data/lib/geocoder/lookups/ip2location.rb

@@ -0,0 +1,67 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ip2location'
+
+module Geocoder::Lookup
+  class Ip2location < Base
+
+    def name
+      "IP2LocationApi"
+    end
+
+    def supported_protocols
+      [:http, :https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.ip2location.com/?"
+    end
+
+    def query_url_params(query)
+      params = super
+      if configuration.has_key?(:package)
+        params.merge!(package: configuration[:package])
+      end
+      params
+    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 doc["response"] == "INVALID ACCOUNT"
+        raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "INVALID ACCOUNT")
+        return []
+      else
+        return [doc]
+      end
+    end
+
+    def reserved_result(query)
+      {
+        "country_code"         => "INVALID IP ADDRESS",
+        "country_name"         => "INVALID IP ADDRESS",
+        "region_name"          => "INVALID IP ADDRESS",
+        "city_name"            => "INVALID IP ADDRESS",
+        "latitude"             => "INVALID IP ADDRESS",
+        "longitude"            => "INVALID IP ADDRESS",
+        "zip_code"             => "INVALID IP ADDRESS",
+        "time_zone"            => "INVALID IP ADDRESS",
+        "isp"                  => "INVALID IP ADDRESS",
+        "domain"               => "INVALID IP ADDRESS",
+        "net_speed"            => "INVALID IP ADDRESS",
+        "idd_code"             => "INVALID IP ADDRESS",
+        "area_code"            => "INVALID IP ADDRESS",
+        "weather_station_code" => "INVALID IP ADDRESS",
+        "weather_station_name" => "INVALID IP ADDRESS",
+        "mcc"                  => "INVALID IP ADDRESS",
+        "mnc"                  => "INVALID IP ADDRESS",
+        "mobile_brand"         => "INVALID IP ADDRESS",
+        "elevation"            => "INVALID IP ADDRESS",
+        "usage_type"           => "INVALID IP ADDRESS"
+      }
+    end
+
+  end
+end

data/lib/geocoder/lookups/ipapi_com.rb

@@ -0,0 +1,82 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipapi_com'
+
+module Geocoder::Lookup
+  class IpapiCom < Base
+
+    def name
+      "ip-api.com"
+    end
+
+    def supported_protocols
+      if configuration.api_key
+        [:http, :https]
+      else
+        [:http]
+      end
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      domain = configuration.api_key ? "pro.ip-api.com" : "ip-api.com"
+      url = "#{protocol}://#{domain}/json/#{query.sanitized_text}"
+      url << "?" if not url_query_string(query).empty?
+      url
+    end
+
+    def parse_raw_data(raw_data)
+      if raw_data.chomp == "invalid key"
+        invalid_key_result
+      else
+        super(raw_data)
+      end
+    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 doc["message"] == "invalid key"
+        raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid API key.")
+        return []
+      else
+        return [doc]
+      end
+    end
+
+    def reserved_result(query)
+      {
+        "message"      => "reserved range",
+        "query"        => query,
+        "status"       => "fail",
+        "ip"           => query,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def invalid_key_result
+      {
+        "message"      => "invalid key"
+      }
+    end
+
+    def query_url_params(query)
+      params = {}
+      params.merge!(fields: configuration[:fields]) if configuration.has_key?(:fields)
+      params.merge!(key: configuration.api_key) if configuration.api_key
+      params.merge(super)
+    end
+
+  end
+end

data/lib/geocoder/lookups/ipdata_co.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipdata_co'
+
+module Geocoder::Lookup
+  class IpdataCo < Base
+
+    def name
+      "ipdata.co"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def query_url(query)
+      # Ipdata.co requires that the API key be sent as a query parameter.
+      # It no longer supports API keys sent as headers.
+      "#{protocol}://#{host}/#{query.sanitized_text}?api-key=#{configuration.api_key}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    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?
+      # note: Ipdata.co returns plain text on bad request
+      (doc = fetch_data(query)) ? [doc] : []
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def host
+      "api.ipdata.co"
+    end
+
+    def check_response_for_errors!(response)
+      if response.code.to_i == 403
+        raise_error(Geocoder::RequestDenied) ||
+          Geocoder.log(:warn, "Geocoding API error: 403 API key does not exist")
+      else
+        super(response)
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/ipgeolocation.rb

@@ -0,0 +1,51 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipgeolocation'
+
+
+module Geocoder::Lookup
+  class Ipgeolocation < Base
+
+    ERROR_CODES = {
+      400 => Geocoder::RequestDenied, # subscription is paused
+      401 => Geocoder::InvalidApiKey, # missing/invalid API key
+      403 => Geocoder::InvalidRequest, # invalid IP address
+      404 => Geocoder::InvalidRequest, # not found
+      423 => Geocoder::InvalidRequest # bogon/reserved IP address
+    }
+    ERROR_CODES.default = Geocoder::Error
+
+    def name
+      "Ipgeolocation"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.ipgeolocation.io/ipgeo?"
+    end
+    def query_url_params(query)
+      {
+          ip: query.sanitized_text,
+          apiKey: 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?
+      [fetch_data(query)]
+    end
+
+    def reserved_result(ip)
+      {
+          "ip"           => ip,
+          "country_name" => "Reserved",
+          "country_code2" => "RD"
+      }
+    end
+  end
+end

data/lib/geocoder/lookups/ipinfo_io.rb

@@ -0,0 +1,44 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipinfo_io'
+
+module Geocoder::Lookup
+  class IpinfoIo < Base
+
+    def name
+      "Ipinfo.io"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      url = "#{protocol}://ipinfo.io/#{query.sanitized_text}/geo"
+      url << "?" if configuration.api_key
+      url
+    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?
+
+      if !(doc = fetch_data(query)).is_a?(Hash) or doc['error']
+        []
+      else
+        [doc]
+      end
+    end
+
+    def reserved_result(ip)
+      {
+        "ip" => ip,
+        "bogon" => true
+      }
+    end
+
+    def query_url_params(query)
+      {
+        token: configuration.api_key
+      }.merge(super)
+    end
+
+  end
+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

@@ -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,59 @@
+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,50 @@
+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
+
+    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] || "locationiq.org"
+    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 []