broken-geocoder 1.3.4

data/lib/geocoder/lookups/google_places_details.rb

@@ -0,0 +1,50 @@
+require "geocoder/lookups/google"
+require "geocoder/results/google_places_details"
+
+module Geocoder
+  module Lookup
+    class GooglePlacesDetails < Google
+      def name
+        "Google Places Details"
+      end
+
+      def required_api_key_parts
+        ["key"]
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      def query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?#{url_query_string(query)}"
+      end
+
+      private
+
+      def results(query)
+        return [] unless doc = fetch_data(query)
+
+        case doc["status"]
+        when "OK"
+          return [doc["result"]]
+        when "OVER_QUERY_LIMIT"
+          raise_error(Geocoder::OverQueryLimitError) || Geocoder.log(:warn, "Google Places Details API error: over query limit.")
+        when "REQUEST_DENIED"
+          raise_error(Geocoder::RequestDenied) || Geocoder.log(:warn, "Google Places Details API error: request denied.")
+        when "INVALID_REQUEST"
+          raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, "Google Places Details API error: invalid request.")
+        end
+
+        []
+      end
+
+      def query_url_google_params(query)
+        {
+          placeid: query.text,
+          language: query.language || configuration.language
+        }
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/google_premier.rb

@@ -0,0 +1,47 @@
+require 'openssl'
+require 'base64'
+require 'geocoder/lookups/google'
+require 'geocoder/results/google_premier'
+
+module Geocoder::Lookup
+  class GooglePremier < Google
+
+    def name
+      "Google Premier"
+    end
+
+    def required_api_key_parts
+      ["private key", "client", "channel"]
+    end
+
+    def query_url(query)
+      path = "/maps/api/geocode/json?" + url_query_string(query)
+      "#{protocol}://maps.googleapis.com#{path}&signature=#{sign(path)}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      query_url_google_params(query).merge(super).merge(
+        :key => nil, # don't use param inherited from Google lookup
+        :client => configuration.api_key[1],
+        :channel => configuration.api_key[2]
+      )
+    end
+
+    def sign(string)
+      raw_private_key = url_safe_base64_decode(configuration.api_key[0])
+      digest = OpenSSL::Digest.new('sha1')
+      raw_signature = OpenSSL::HMAC.digest(digest, raw_private_key, string)
+      url_safe_base64_encode(raw_signature)
+    end
+
+    def url_safe_base64_decode(base64_string)
+      Base64.decode64(base64_string.tr('-_', '+/'))
+    end
+
+    def url_safe_base64_encode(raw)
+      Base64.encode64(raw).tr('+/', '-_').strip
+    end
+  end
+end

data/lib/geocoder/lookups/here.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/here'
+
+module Geocoder::Lookup
+  class Here < Base
+
+    def name
+      "Here"
+    end
+
+    def required_api_key_parts
+      ["app_id", "app_code"]
+    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)
+    end
+
+    private # ---------------------------------------------------------------
+
+    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']
+      end
+      []
+    end
+
+    def query_url_params(query)
+      options = {
+        :gen=>4,
+        :app_id=>api_key,
+        :app_code=>api_code
+      }
+
+      if query.reverse_geocode?
+        super.merge(options).merge(
+          :prox=>query.sanitized_text,
+          :mode=>:retrieveAddresses
+        )
+      else
+        super.merge(options).merge(
+          :searchtext=>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_code
+      if a=configuration.api_key
+        return a.last if a.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/ipapi_com.rb

@@ -0,0 +1,86 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipapi_com'
+
+module Geocoder::Lookup
+  class IpapiCom < Base
+
+    def name
+      "ip-api.com"
+    end
+
+    def query_url(query)
+      domain = configuration.api_key ? "pro.ip-api.com" : "ip-api.com"
+      url_ = "#{protocol}://#{domain}/json/#{query.sanitized_text}"
+
+      if (params = url_query_string(query)) && !params.empty?
+        url_ + "?" + params
+      else
+        url_
+      end
+    end
+
+    def supported_protocols
+      if configuration.api_key
+        [:http, :https]
+      else
+        [:http]
+      end
+    end
+
+
+    private
+
+    def parse_raw_data(raw_data)
+      if raw_data.chomp == "invalid key"
+        invalid_key_result
+      else
+        super(raw_data)
+      end
+    end
+
+    def results(query)
+      return [reserved_result(query.text)] if query.loopback_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/ipinfo_io.rb

@@ -0,0 +1,55 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipinfo_io'
+
+module Geocoder::Lookup
+  class IpinfoIo < Base
+
+    def name
+      "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
+
+    # HTTPS available only for paid plans
+    def supported_protocols
+      if configuration.api_key
+        [:http, :https]
+      else
+        [:http]
+      end
+    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)
+        []
+      else
+        [doc]
+      end
+    end
+
+    def empty_result?(doc)
+      !doc.is_a?(Hash) or doc.keys == ["ip"]
+    end
+
+    def reserved_result(ip)
+      {"message" => "Input string is not a valid IP address", "code" => 401}
+    end
+
+    def query_url_params(query)
+      {
+        token: configuration.api_key
+      }.merge(super)
+    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
+
+    def query_url(query)
+      "#{protocol}://latlon.io/api/v1/#{'reverse_' if query.reverse_geocode?}geocode?#{url_query_string(query)}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    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/mapbox.rb

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/mapbox"
+
+module Geocoder::Lookup
+  class Mapbox < Base
+
+    def name
+      "Mapbox"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{url_query_string(query)}.json?access_token=#{configuration.api_key}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    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 url_query_string(query)
+      require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        "#{CGI.escape lon},#{CGI.escape lat}"
+      else
+        CGI.escape query.text.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,59 @@
+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
+
+    def query_url(query)
+      domain = configuration[:open] ? "open" : "www"
+      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
+      url + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    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