geocoder 1.4.8 → 1.6.0

data/lib/geocoder/lookups/nominatim.rb

@@ -12,13 +12,13 @@ module Geocoder::Lookup
       "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"
-      "#{protocol}://#{configured_host}/#{method}?" + url_query_string(query)
+      "#{protocol}://#{configured_host}/#{method}?"
     end
 
-    private # ---------------------------------------------------------------
-
     def configured_host
       configuration[:host] || "nominatim.openstreetmap.org"
     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)
@@ -44,6 +44,7 @@ module Geocoder::Lookup
     def query_url_params(query)
       params = {
         :q => query.sanitized_text,
+        :key => configuration.api_key,
         :language => (query.language || configuration.language)
       }.merge(super)
 

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

@@ -11,25 +11,24 @@ module Geocoder::Lookup
       configuration[:endpoint] || 'localhost'
     end
 
-    def query_url(query)
-      query_type = query.reverse_geocode? ? 'reverse' : 'search'
-      "#{protocol}://#{endpoint}/v1/#{query_type}?" + url_query_string(query)
-    end
-
     def required_api_key_parts
       ['search-XXXX']
     end
 
-    private
+    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,
-        size: 1
+        api_key: configuration.api_key
       }.merge(super)
 
       if query.reverse_geocode?
-        lat,lon = query.coordinates
+        lat, lon = query.coordinates
         params[:'point.lat'] = lat
         params[:'point.lon'] = lon
       else

data/lib/geocoder/lookups/pickpoint.rb

@@ -15,12 +15,18 @@ module Geocoder::Lookup
       ["api_key"]
     end
 
-    def query_url(query)
+    private # ----------------------------------------------------------------
+
+    def base_query_url(query)
       method = query.reverse_geocode? ? "reverse" : "forward"
-      "#{protocol}://api.pickpoint.io/v1/#{method}?key=#{configuration.api_key}&" + url_query_string(query)
+      "#{protocol}://api.pickpoint.io/v1/#{method}?"
     end
 
-    private
+    def query_url_params(query)
+      {
+        key: configuration.api_key
+      }.merge(super)
+    end
 
     def results(query)
       return [] unless doc = fetch_data(query)

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)
@@ -38,7 +42,7 @@ module Geocoder::Lookup
           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)

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,15 +8,7 @@ module Geocoder::Lookup
     end
 
     def required_api_key_parts
-      %w(auti-id auth-token)
-    end
-
-    def query_url(query)
-      if zipcode_only?(query)
-        "#{protocol}://us-zipcode.api.smartystreets.com/lookup?#{url_query_string(query)}"
-      else
-        "#{protocol}://us-street.api.smartystreets.com/street-address?#{url_query_string(query)}"
-      end
+      %w(auth-id auth-token)
     end
 
     # required by API as of 26 March 2015
@@ -26,13 +18,31 @@ module Geocoder::Lookup
 
     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

@@ -29,9 +29,13 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
+    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
@@ -44,7 +48,23 @@ 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

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

data/lib/geocoder/lookups/yandex.rb

@@ -12,16 +12,16 @@ module Geocoder::Lookup
       "http://maps.yandex.ru/?ll=#{coordinates.reverse.join(',')}"
     end
 
-    def query_url(query)
-      "#{protocol}://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
-    end
-    
     def supported_protocols
       [:https]
     end
 
     private # ---------------------------------------------------------------
 
+    def base_query_url(query)
+      "#{protocol}://geocode-maps.yandex.ru/1.x/?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
       if err = doc['error']
@@ -50,8 +50,8 @@ module Geocoder::Lookup
       params = {
         :geocode => q,
         :format => "json",
-        :plng => "#{query.language || configuration.language}", # supports ru, uk, be
-        :key => configuration.api_key
+        :lang => "#{query.language || configuration.language}", # supports ru, uk, be, default -> ru
+        :apikey => configuration.api_key
       }
       unless (bounds = query.options[:bounds]).nil?
         params[:bbox] = bounds.map{ |point| "%f,%f" % point }.join('~')