geocoder 1.1.9 → 1.3.7

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

@@ -31,7 +31,7 @@ module Geocoder::Lookup
 
     def sign(string)
       raw_private_key = url_safe_base64_decode(configuration.api_key[0])
-      digest = OpenSSL::Digest::Digest.new('sha1')
+      digest = OpenSSL::Digest.new('sha1')
       raw_signature = OpenSSL::HMAC.digest(digest, raw_private_key, string)
       url_safe_base64_encode(raw_signature)
     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

@@ -14,9 +14,8 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      domain = configuration[:licensed] ? "www" : "open"
-      version = configuration[:version] || 1
-      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v#{version}/#{search_type(query)}?"
+      domain = configuration[:open] ? "open" : "www"
+      url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
       url + url_query_string(query)
     end
 
@@ -45,14 +44,15 @@ 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
 
   end

data/lib/geocoder/lookups/mapzen.rb

@@ -0,0 +1,15 @@
+require 'geocoder/lookups/pelias'
+require 'geocoder/results/mapzen'
+
+# https://mapzen.com/documentation/search/search/ for more information
+module Geocoder::Lookup
+  class Mapzen < Pelias
+    def name
+      'Mapzen'
+    end
+
+    def endpoint
+      configuration[:endpoint] || 'search.mapzen.com'
+    end
+  end
+end

data/lib/geocoder/lookups/maxmind.rb

@@ -64,14 +64,16 @@ module Geocoder::Lookup
         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 []
     end
 
     def parse_raw_data(raw_data)
-      CSV.parse_line raw_data
+      # Maxmind just returns text/plain as csv format but according to documentation,
+      # we get ISO-8859-1 encoded string. We need to convert it.
+      CSV.parse_line raw_data.force_encoding("ISO-8859-1").encode("UTF-8")
     end
 
     def reserved_result

data/lib/geocoder/lookups/maxmind_geoip2.rb

@@ -0,0 +1,69 @@
+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!}/#{URI.escape(query.sanitized_text.strip)}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    ##
+    # 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 name and basic_auth: " +
+          "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 address
+      return [] if query.loopback_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

@@ -0,0 +1,65 @@
+require 'ipaddr'
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind_local'
+
+module Geocoder::Lookup
+  class MaxmindLocal < Base
+
+    def initialize
+      if !configuration[:file].nil?
+        begin
+          gem = RUBY_PLATFORM == 'java' ? 'jgeoip' : 'geoip'
+          require gem
+        rescue LoadError
+          raise "Could not load geoip dependency. To use MaxMind Local lookup you must add the #{gem} gem to your Gemfile or have it installed in your system."
+        end
+      end
+      super
+    end
+
+    def name
+      "MaxMind Local"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    private
+
+    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? ? [] : [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)"
+        format_result(q, [:country_name, :region_name, :city_name, :latitude, :longitude])
+      elsif configuration[:package] == :country
+        addr = IPAddr.new(query.text).to_i
+        q = "SELECT country, country_code FROM maxmind_geolite_country
+          WHERE start_ip_num <= #{addr} AND #{addr} <= end_ip_num"
+        format_result(q, [:country_name, :country_code2])
+      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
+        [Hash[*attr_names.zip(r).flatten]]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/nominatim.rb

@@ -25,11 +25,19 @@ module Geocoder::Lookup
       doc.is_a?(Array) ? doc : [doc]
     end
 
+    def parse_raw_data(raw_data)
+      if raw_data.include?("Bandwidth limit exceeded")
+        raise_error(Geocoder::OverQueryLimitError) || Geocoder.log(:warn, "Over API query limit.")
+      else
+        super(raw_data)
+      end
+    end
+
     def query_url_params(query)
       params = {
         :format => "json",
         :addressdetails => "1",
-        :"accept-language" => configuration.language
+        :"accept-language" => (query.language || configuration.language)
       }.merge(super)
       if query.reverse_geocode?
         lat,lon = query.coordinates

data/lib/geocoder/lookups/okf.rb

@@ -0,0 +1,44 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/okf"
+
+module Geocoder::Lookup
+  class Okf < Base
+
+    def name
+      "Okf"
+    end
+
+    def query_url(query)
+      "#{protocol}://data.okf.fi/gis/1/geocode/json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def valid_response?(response)
+      json = parse_json(response.body)
+      status = json["status"] if json
+      super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      case doc['status']; when "OK" # OK status implies >0 results
+        return doc['results']
+      end
+      return []
+    end
+
+    def query_url_okf_params(query)
+      params = {
+        (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
+        :sensor => "false",
+        :language => (query.language || configuration.language)
+      }
+      params
+    end
+
+    def query_url_params(query)
+      query_url_okf_params(query).merge(super)
+    end
+  end
+end