geocoder 1.2.6 → 1.8.2

data/lib/geocoder/lookups/google_places_search.rb

@@ -0,0 +1,76 @@
+require "geocoder/lookups/google"
+require "geocoder/results/google_places_search"
+
+module Geocoder
+  module Lookup
+    class GooglePlacesSearch < Google
+      def name
+        "Google Places Search"
+      end
+
+      def required_api_key_parts
+        ["key"]
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def result_root_attr
+        'candidates'
+      end
+
+      def base_query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/findplacefromtext/json?"
+      end
+
+      def query_url_google_params(query)
+        {
+          input: query.text,
+          inputtype: 'textquery',
+          fields: fields(query),
+          locationbias: locationbias(query),
+          language: query.language || configuration.language
+        }
+      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
+
+        default_fields
+      end
+
+      def default_fields
+        legacy = %w[id reference]
+        basic = %w[business_status formatted_address geometry icon name 
+          photos place_id plus_code types]
+        contact = %w[opening_hours]
+        atmosphere = %W[price_level rating user_ratings_total]
+        format_fields(legacy, basic, contact, atmosphere)
+      end
+
+      def format_fields(*fields)
+        flattened = fields.flatten.compact
+        return if flattened.empty?
+
+        flattened.join(',')
+      end
+
+      def locationbias(query)
+        if query.options.has_key?(:locationbias)
+          query.options[:locationbias]
+        else
+          configuration[:locationbias]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/google_premier.rb

@@ -11,7 +11,7 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      ["private key", "client", "channel"]
+      ["private key"]
     end
 
     def query_url(query)
@@ -21,6 +21,20 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    def result_root_attr
+      'results'
+    end
+
+    def cache_key(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + hash_to_query(cache_key_params(query))
+    end
+
+    def cache_key_params(query)
+      query_url_google_params(query).merge(super).reject do |k,v|
+        [:key, :client, :channel].include?(k)
+      end
+    end
+
     def query_url_params(query)
       query_url_google_params(query).merge(super).merge(
         :key => nil, # don't use param inherited from Google lookup

data/lib/geocoder/lookups/here.rb

@@ -9,54 +9,65 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      []
+      ['api_key']
     end
 
-    def query_url(query)
-      "#{protocol}://#{if query.reverse_geocode? then 'reverse.' end}geocoder.api.here.com/6.2/#{if query.reverse_geocode? then 'reverse' end}geocode.json?" + url_query_string(query)
+    def supported_protocols
+      [:https]
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      service = query.reverse_geocode? ? "revgeocode" : "geocode"
+
+      "#{protocol}://#{service}.search.hereapi.com/v1/#{service}?"
+    end
+
     def results(query)
-      return [] unless doc = fetch_data(query)
-      return [] unless doc['Response'] && doc['Response']['View']
-      if r=doc['Response']['View']
-        return [] if r.nil? || !r.is_a?(Array) || r.empty?
-        return r.first['Result']
+      unless configuration.api_key.is_a?(String)
+        api_key_not_string!
+        return []
       end
-      []
+      return [] unless doc = fetch_data(query)
+      return [] if doc["items"].nil?
+
+      doc["items"]
     end
 
-    def query_url_params(query)
+    def query_url_here_options(query, reverse_geocode)
       options = {
-        :gen=>4,
-        :app_id=>api_key,
-        :app_code=>api_code
+        apiKey: configuration.api_key,
+        lang: (query.language || configuration.language)
       }
+      return options if reverse_geocode
 
+      unless (country = query.options[:country]).nil?
+        options[:in] = "countryCode:#{country}"
+      end
+
+      options
+    end
+
+    def query_url_params(query)
       if query.reverse_geocode?
-        super.merge(options).merge(
-          :prox=>query.sanitized_text,
-          :mode=>:retrieveAddresses
+        super.merge(query_url_here_options(query, true)).merge(
+          at: query.sanitized_text
         )
       else
-        super.merge(options).merge(
-          :searchtext=>query.sanitized_text
+        super.merge(query_url_here_options(query, false)).merge(
+          q: query.sanitized_text
         )
       end
     end
 
-    def api_key
-      if a=configuration.api_key
-        return a.first if a.is_a?(Array)
-      end
-    end
+    def api_key_not_string!
+      msg = <<~MSG
+        API key for HERE Geocoding and Search API should be a string.
+        For more info on how to obtain it, please see https://developer.here.com/documentation/identity-access-management/dev_guide/topics/plat-using-apikeys.html
+      MSG
 
-    def api_code
-      if a=configuration.api_key
-        return a.last if a.is_a?(Array)
-      end
+      raise_error(Geocoder::ConfigurationError, msg) || Geocoder.log(:warn, msg)
     end
   end
 end

data/lib/geocoder/lookups/ip2location.rb

@@ -0,0 +1,71 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ip2location'
+
+module Geocoder::Lookup
+  class Ip2location < Base
+
+    def name
+      "IP2LocationApi"
+    end
+
+    def required_api_key_parts
+      ['key']
+    end
+
+    def supported_protocols
+      [:http, :https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.ip2location.com/v2/?"
+    end
+
+    def query_url_params(query)
+      super.merge(
+        key: configuration.api_key,
+        ip: query.sanitized_text,
+        package: configuration[:package],
+      )
+    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/ipbase.rb

@@ -0,0 +1,49 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipbase'
+
+module Geocoder::Lookup
+  class Ipbase < Base
+
+    def name
+      "ipbase.com"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "https://api.ipbase.com/v2/info?"
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :apikey => configuration.api_key
+      }
+    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?
+      doc = fetch_data(query) || {}
+      doc.fetch("data", {})["location"] ? [doc] : []
+    end
+
+    def reserved_result(ip)
+      {
+        "data" => {
+          "ip" => ip,
+          "location" => {
+            "city" => { "name" => "" },
+            "country" => { "alpha2" => "RD", "name" => "Reserved" },
+            "region" => { "alpha2" => "", "name" => "" },
+            "zip" => ""
+          }
+        }
+      }
+    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
+      configuration[: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/ipqualityscore.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipqualityscore'
+
+module Geocoder::Lookup
+  class Ipqualityscore < Base
+
+    def name
+      "IPQualityScore"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipqualityscore.com/api/json/ip/#{configuration.api_key}/#{query.sanitized_text}?"
+    end
+
+    def valid_response?(response)
+      if (json = parse_json(response.body))
+        success = json['success']
+      end
+      super && success == true
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+
+      return [doc] if doc['success']
+
+      case doc['message']
+      when /invalid (.*) key/i
+        raise_error Geocoder::InvalidApiKey ||
+                    Geocoder.log(:warn, "#{name} API error: invalid api key.")
+      when /insufficient credits/, /exceeded your request quota/
+        raise_error Geocoder::OverQueryLimitError ||
+                    Geocoder.log(:warn, "#{name} API error: query limit exceeded.")
+      when /invalid (.*) address/i
+        raise_error Geocoder::InvalidRequest ||
+                    Geocoder.log(:warn, "#{name} API error: invalid request.")
+      end
+
+      [doc]
+    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