geocoder 1.2.6 → 1.6.1

data/lib/geocoder/lookups/maxmind_geoip2.rb

@@ -0,0 +1,70 @@
+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!}/#{query.sanitized_text.strip}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    ##
+    # 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 and credentials: 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 or private address, just return the stored result
+      return [] if query.internal_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

@@ -31,12 +31,12 @@ module Geocoder::Lookup
       if configuration[:file]
         geoip_class = RUBY_PLATFORM == "java" ? JGeoIP : GeoIP
         result = geoip_class.new(configuration[:file]).city(query.to_s)
-        result.nil? ? [] : [result.to_hash]
+        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 LIMIT 1)"
+          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
@@ -46,6 +46,13 @@ module Geocoder::Lookup
       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

data/lib/geocoder/lookups/nominatim.rb

@@ -9,16 +9,28 @@ module Geocoder::Lookup
     end
 
     def map_link_url(coordinates)
-      "http://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
+      "https://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
     end
 
-    def query_url(query)
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
       method = query.reverse_geocode? ? "reverse" : "search"
-      host = configuration[:host] || "nominatim.openstreetmap.org"
-      "#{protocol}://#{host}/#{method}?" + url_query_string(query)
+      "#{protocol}://#{configured_host}/#{method}?"
     end
 
-    private # ---------------------------------------------------------------
+    def configured_host
+      configuration[:host] || "nominatim.openstreetmap.org"
+    end
+
+    def use_ssl?
+      # nominatim.openstreetmap.org redirects HTTP requests to HTTPS
+      if configured_host == "nominatim.openstreetmap.org"
+        true
+      else
+        super
+      end
+    end
 
     def results(query)
       return [] unless doc = fetch_data(query)
@@ -27,7 +39,7 @@ module Geocoder::Lookup
 
     def parse_raw_data(raw_data)
       if raw_data.include?("Bandwidth limit exceeded")
-        raise_error(Geocoder::OverQueryLimitError) || warn("Over API query limit.")
+        raise_error(Geocoder::OverQueryLimitError) || Geocoder.log(:warn, "Over API query limit.")
       else
         super(raw_data)
       end

data/lib/geocoder/lookups/opencagedata.rb

@@ -8,15 +8,15 @@ module Geocoder::Lookup
       "OpenCageData"
     end
 
-    def query_url(query)
-      "#{protocol}://api.opencagedata.com/geocode/v1/json?key=#{configuration.api_key}&#{url_query_string(query)}"
-    end
-
     def required_api_key_parts
       ["key"]
     end
 
-    private
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://api.opencagedata.com/geocode/v1/json?"
+    end
 
     def results(query)
       return [] unless doc = fetch_data(query)
@@ -26,16 +26,16 @@ module Geocoder::Lookup
       case doc['status']['code']
       when 400 # Error with input
         raise_error(Geocoder::InvalidRequest, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       when 403 # Key related error
         raise_error(Geocoder::InvalidApiKey, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       when 402 # Quata Exceeded
           raise_error(Geocoder::OverQueryLimitError, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       when 500 # Unknown error
         raise_error(Geocoder::Error, messages) ||
-          warn("Opencagedata Geocoding API error: #{messages}")
+          Geocoder.log(:warn, "Opencagedata Geocoding API error: #{messages}")
       end
 
       return doc["results"]
@@ -44,9 +44,16 @@ module Geocoder::Lookup
     def query_url_params(query)
       params = {
         :q => query.sanitized_text,
+        :key => configuration.api_key,
         :language => (query.language || configuration.language)
       }.merge(super)
 
+      [:abbrv, :countrycode, :min_confidence, :no_dedupe, :no_annotations, :no_record, :limit].each do |option|
+        unless (option_value = query.options[option]).nil?
+          params[option] = option_value
+        end
+      end
+
       unless (bounds = query.options[:bounds]).nil?
         params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join(',')
       end

data/lib/geocoder/lookups/osmnames.rb

@@ -0,0 +1,57 @@
+require 'cgi'
+require 'geocoder/lookups/base'
+require 'geocoder/results/osmnames'
+
+module Geocoder::Lookup
+  class Osmnames < Base
+
+    def name
+      'OSM Names'
+    end
+
+    def required_api_key_parts
+      configuration[:host] ? [] : ['key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private
+
+    def base_query_url(query)
+      "#{base_url(query)}/#{params_url(query)}.js?"
+    end
+
+    def base_url(query)
+      host = configuration[:host] || 'geocoder.tilehosting.com'
+      "#{protocol}://#{host}"
+    end
+
+    def params_url(query)
+      method, args = 'q', CGI.escape(query.sanitized_text)
+      method, args = 'r', query.coordinates.join('/') if query.reverse_geocode?
+      "#{country_limited(query)}#{method}/#{args}"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if (error = doc['message'])
+        raise_error(Geocoder::InvalidRequest, error) ||
+          Geocoder.log(:warn, "OSMNames Geocoding API error: #{error}")
+      else
+        return doc['results']
+      end
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
+
+    def country_limited(query)
+      "#{query.options[:country_code].downcase}/" if query.options[:country_code] && !query.reverse_geocode?
+    end
+  end
+end

data/lib/geocoder/lookups/pelias.rb

@@ -0,0 +1,63 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/pelias'
+
+module Geocoder::Lookup
+  class Pelias < Base
+    def name
+      'Pelias'
+    end
+
+    def endpoint
+      configuration[:endpoint] || 'localhost'
+    end
+
+    def required_api_key_parts
+      ['search-XXXX']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      query_type = query.reverse_geocode? ? 'reverse' : 'search'
+      "#{protocol}://#{endpoint}/v1/#{query_type}?"
+    end
+
+    def query_url_params(query)
+      params = {
+        api_key: configuration.api_key
+      }.merge(super)
+
+      if query.reverse_geocode?
+        lat, lon = query.coordinates
+        params[:'point.lat'] = lat
+        params[:'point.lon'] = lon
+      else
+        params[:text] = query.text
+      end
+      params
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      # not all responses include a meta
+      if doc['meta']
+        error = doc.fetch('results', {}).fetch('error', {})
+        message = error.fetch('type', 'Unknown Error') + ': ' + error.fetch('message', 'No message')
+        log_message = 'Pelias Geocoding API error - ' + message
+        case doc['meta']['status_code']
+          when '200'
+            # nothing to see here
+          when '403'
+            raise_error(Geocoder::RequestDenied, message) || Geocoder.log(:warn, log_message)
+          when '429'
+            raise_error(Geocoder::OverQueryLimitError, message) || Geocoder.log(:warn, log_message)
+          else
+            raise_error(Geocoder::Error, message) || Geocoder.log(:warn, log_message)
+        end
+      end
+
+      doc['features'] || []
+    end
+  end
+end

data/lib/geocoder/lookups/pickpoint.rb

@@ -0,0 +1,41 @@
+require "geocoder/lookups/nominatim"
+require "geocoder/results/pickpoint"
+
+module Geocoder::Lookup
+  class Pickpoint < Nominatim
+    def name
+      "Pickpoint"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def required_api_key_parts
+      ["api_key"]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "forward"
+      "#{protocol}://api.pickpoint.io/v1/#{method}?"
+    end
+
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if !doc.is_a?(Array) && doc['message'] == 'Unauthorized'
+        raise_error(Geocoder::InvalidApiKey, 'Unauthorized')
+      end
+
+      doc.is_a?(Array) ? doc : [doc]
+    end
+  end
+end

data/lib/geocoder/lookups/pointpin.rb

@@ -13,14 +13,18 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{ protocol }://geo.pointp.in/#{ api_key }/json/#{ query.sanitized_text }"
+      "#{protocol}://geo.pointp.in/#{configuration.api_key}/json/#{query.sanitized_text}"
     end
 
-  private
+    private # ----------------------------------------------------------------
+
+    def cache_key(query)
+      "#{protocol}://geo.pointp.in/json/#{query.sanitized_text}"
+    end
 
     def results(query)
-      # don't look up a loopback address, just return the stored result
-      return [] if query.loopback_ip_address?
+      # don't look up a loopback or private address, just return the stored result
+      return [] if query.internal_ip_address?
       doc = fetch_data(query)
       if doc and doc.is_a?(Hash)
         if !data_contains_error?(doc)
@@ -28,17 +32,17 @@ module Geocoder::Lookup
         elsif doc['error']
           case doc['error']
           when "Invalid IP address"
-            raise_error(Geocoder::InvalidRequest) || warn("Invalid Pointpin request.")
+            raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, "Invalid Pointpin request.")
           when "Invalid API key"
-            raise_error(Geocoder::InvalidApiKey) || warn("Invalid Pointpin API key.")
+            raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid Pointpin API key.")
           when "Address not found"
-            warn("Address not found.")
+            Geocoder.log(:warn, "Address not found.")
           end
         else
-          raise_error(Geocoder::Error) || warn("Pointpin server error")
+          raise_error(Geocoder::Error) || Geocoder.log(:warn, "Pointpin server error")
         end
       end
-      
+
       return []
     end
 
@@ -46,6 +50,7 @@ module Geocoder::Lookup
       parsed_data.keys.include?('error')
     end
 
+    # TODO: replace this hash with what's actually returned by Pointpin
     def reserved_result(ip)
       {
         "ip"           => ip,
@@ -60,9 +65,5 @@ module Geocoder::Lookup
         "country_code" => "RD"
       }
     end
-
-    def api_key
-      configuration.api_key
-    end
   end
 end

data/lib/geocoder/lookups/postcode_anywhere_uk.rb

@@ -4,7 +4,6 @@ require 'geocoder/results/postcode_anywhere_uk'
 module Geocoder::Lookup
   class PostcodeAnywhereUk < Base
     # API documentation: http://www.postcodeanywhere.co.uk/Support/WebService/Geocoding/UK/Geocode/2/
-    BASE_URL_GEOCODE_V2_00 = 'services.postcodeanywhere.co.uk/Geocoding/UK/Geocode/v2.00/json.ws'
     DAILY_LIMIT_EXEEDED_ERROR_CODES = ['8', '17'] # api docs say these two codes are the same error
     INVALID_API_KEY_ERROR_CODE = '2'
 
@@ -16,11 +15,11 @@ module Geocoder::Lookup
       %w(key)
     end
 
-    def query_url(query)
-      format('%s://%s?%s', protocol, BASE_URL_GEOCODE_V2_00, url_query_string(query))
-    end
+    private # ----------------------------------------------------------------
 
-    private
+    def base_query_url(query)
+      "#{protocol}://services.postcodeanywhere.co.uk/Geocoding/UK/Geocode/v2.00/json.ws?"
+    end
 
     def results(query)
       response = fetch_data(query)
@@ -33,11 +32,11 @@ module Geocoder::Lookup
     def raise_exception_for_response(response)
       case response['Error']
       when *DAILY_LIMIT_EXEEDED_ERROR_CODES
-        raise_error(Geocoder::OverQueryLimitError, response['Cause']) || warn(response['Cause'])
+        raise_error(Geocoder::OverQueryLimitError, response['Cause']) || Geocoder.log(:warn, response['Cause'])
       when INVALID_API_KEY_ERROR_CODE
-        raise_error(Geocoder::InvalidApiKey, response['Cause']) || warn(response['Cause'])
+        raise_error(Geocoder::InvalidApiKey, response['Cause']) || Geocoder.log(:warn, response['Cause'])
       else # anything else just raise general error with the api cause
-        raise_error(Geocoder::Error, response['Cause']) || warn(response['Cause'])
+        raise_error(Geocoder::Error, response['Cause']) || Geocoder.log(:warn, response['Cause'])
       end
     end
 

data/lib/geocoder/lookups/postcodes_io.rb

@@ -0,0 +1,31 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/postcodes_io'
+
+module Geocoder::Lookup
+  class PostcodesIo < Base
+    def name
+      'Postcodes.io'
+    end
+
+    def query_url(query)
+      "#{protocol}://api.postcodes.io/postcodes/#{query.sanitized_text.gsub(/\s/, '')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def cache_key(query)
+      query_url(query)
+    end
+
+    def results(query)
+      response = fetch_data(query)
+      return [] if response.nil? || response['status'] != 200 || response.empty?
+
+      [response['result']]
+    end
+  end
+end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -8,23 +8,41 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      %w(auti-id auth-token)
+      %w(auth-id auth-token)
     end
 
-    def query_url(query)
-      path = zipcode_only?(query) ? "zipcode" : "street-address"
-      "#{protocol}://api.smartystreets.com/#{path}?#{url_query_string(query)}"
+    # required by API as of 26 March 2015
+    def supported_protocols
+      [:https]
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      if international?(query)
+        "#{protocol}://international-street.api.smartystreets.com/verify?"
+      elsif zipcode_only?(query)
+        "#{protocol}://us-zipcode.api.smartystreets.com/lookup?"
+      else
+        "#{protocol}://us-street.api.smartystreets.com/street-address?"
+      end
+    end
+
     def zipcode_only?(query)
       !query.text.is_a?(Array) and query.to_s.strip =~ /\A\d{5}(-\d{4})?\Z/
     end
 
+    def international?(query)
+      !query.options[:country].nil?
+    end
+
     def query_url_params(query)
       params = {}
-      if zipcode_only?(query)
+      if international?(query)
+        params[:freeform] = query.sanitized_text
+        params[:country] = query.options[:country]
+        params[:geocode] = true
+      elsif zipcode_only?(query)
         params[:zipcode] = query.sanitized_text
       else
         params[:street] = query.sanitized_text

data/lib/geocoder/lookups/telize.rb

@@ -8,20 +8,34 @@ module Geocoder::Lookup
       "Telize"
     end
 
+    def required_api_key_parts
+      configuration[:host] ? [] : ["key"]
+    end
+
     def query_url(query)
-      #currently doesn't support HTTPS
-      "http://www.telize.com/geoip/#{query.sanitized_text}"
+      if configuration[:host]
+        "#{protocol}://#{configuration[:host]}/location/#{query.sanitized_text}"
+      else
+        "#{protocol}://telize-v1.p.mashape.com/location/#{query.sanitized_text}?mashape-key=#{api_key}"
+      end
+    end
+
+    def supported_protocols
+      [].tap do |array|
+        array << :https
+        array << :http if configuration[:host]
+      end
     end
 
     private # ---------------------------------------------------------------
 
-    def use_ssl?
-      false
+    def cache_key(query)
+      query_url(query)[/(.*)\?.*/, 1]
     end
 
     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?
+      # 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)).nil? or doc['code'] == 401 or empty_result?(doc)
         []
       else
@@ -34,7 +48,28 @@ module Geocoder::Lookup
     end
 
     def reserved_result(ip)
-      {"message" => "Input string is not a valid IP address", "code" => 401}
+      {
+        "ip" => ip,
+        "latitude" => 0,
+        "longitude" => 0,
+        "city" => "",
+        "timezone" => "",
+        "asn" => 0,
+        "region" => "",
+        "offset" => 0,
+        "organization" => "",
+        "country_code" => "",
+        "country_code3" => "",
+        "postal_code" => "",
+        "continent_code" => "",
+        "country" => "",
+        "region_code" => ""
+      }
     end
+
+    def api_key
+      configuration.api_key
+    end
+
   end
 end

data/lib/geocoder/lookups/tencent.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/tencent"
+
+module Geocoder::Lookup
+  class Tencent < Base
+
+    def name
+      "Tencent"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://apis.map.qq.com/ws/geocoder/v1/?"
+    end
+
+    def content_key
+      'result'
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc[content_key]]
+      when 311
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid api key.")
+      when 310
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request, invalid parameters.")
+      when 306
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request, check response for more info.")
+      when 110
+        raise_error(Geocoder::RequestDenied, "request denied.") ||
+          Geocoder.log(:warn, "#{name} Geocoding API error: request source is not authorized.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        (query.reverse_geocode? ? :location : :address) => query.sanitized_text,
+        :key => configuration.api_key,
+        :output => "json"
+      }.merge(super)
+    end
+
+  end
+end