really-broken-geocoder 1.5.1

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/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/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

@@ -0,0 +1,58 @@
+require 'cgi'
+require 'geocoder/lookups/base'
+require "geocoder/results/mapquest"
+
+module Geocoder::Lookup
+  class Mapquest < Base
+
+    def name
+      "Mapquest"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      domain = configuration[:open] ? "open" : "www"
+      "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
+    end
+
+    def search_type(query)
+      query.reverse_geocode? ? "reverse" : "address"
+    end
+
+    def query_url_params(query)
+      params = { :location => query.sanitized_text }
+      if key = configuration.api_key
+        params[:key] = CGI.unescape(key)
+      end
+      params.merge(super)
+    end
+
+    # http://www.mapquestapi.com/geocoding/status_codes.html
+    # http://open.mapquestapi.com/geocoding/status_codes.html
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc["results"][0]['locations'] if doc['info']['statuscode'] == 0 # A successful geocode call
+
+      messages = doc['info']['messages'].join
+
+      case doc['info']['statuscode']
+      when 400 # Error with input
+        raise_error(Geocoder::InvalidRequest, messages) ||
+          Geocoder.log(:warn, "Mapquest Geocoding API error: #{messages}")
+      when 403 # Key related error
+        raise_error(Geocoder::InvalidApiKey, messages) ||
+          Geocoder.log(:warn, "Mapquest Geocoding API error: #{messages}")
+      when 500 # Unknown error
+        raise_error(Geocoder::Error, messages) ||
+          Geocoder.log(:warn, "Mapquest Geocoding API error: #{messages}")
+      end
+      []
+    end
+
+  end
+end