geocoder 1.2.6 → 1.8.2

data/lib/geocoder/lookups/pc_miler.rb

@@ -0,0 +1,85 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/pc_miler"
+require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+
+module Geocoder::Lookup
+  class PcMiler < Base
+
+    # https://developer.trimblemaps.com/restful-apis/location/single-search/single-search-api/#test-the-api-now
+    def valid_region_codes
+      # AF: Africa
+      # AS: Asia
+      # EU: Europe
+      # NA: North America
+      # OC: Oceania
+      # SA: South America
+      %w[AF AS EU NA OC SA]
+    end
+
+    def name
+      "PCMiler"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      region_code = region(query)
+      if !valid_region_codes.include?(region_code)
+        raise "region_code '#{region_code}' is invalid. use one of #{valid_region_codes}." \
+          "https://developer.trimblemaps.com/restful-apis/location/single-search/single-search-api/#test-the-api-now"
+      end
+
+      "#{protocol}://singlesearch.alk.com/#{region_code}/api/search?"
+    end
+
+    def results(query)
+      return [] unless data = fetch_data(query)
+      if data['Locations']
+        add_metadata_to_locations!(data)
+        data['Locations']
+      else
+        []
+      end
+    end
+
+    def add_metadata_to_locations!(data)
+      confidence = data['QueryConfidence']
+      data['Locations'].each do |location|
+        location['QueryConfidence'] = confidence
+      end
+    end
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        formatted_query = "#{CGI.escape(lat)},#{CGI.escape(lon)}"
+      else
+        formatted_query = query.text.to_s
+      end
+
+      {
+        authToken: configuration.api_key,
+        query: formatted_query,
+        # to add additional metadata to response such as QueryConfidence
+        include: 'Meta'
+      }.merge(super(query))
+    end
+
+    def region(query)
+      query.options[:region] || query.options['region'] || configuration[:region] || "NA"
+    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
+
+    def supported_protocols
+      [:https]
+    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/photon.rb

@@ -0,0 +1,89 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/photon'
+
+module Geocoder::Lookup
+  class Photon < Base
+    def name
+      'Photon'
+    end
+
+    private # ---------------------------------------------------------------
+
+    def supported_protocols
+      [:https]
+    end
+
+    def base_query_url(query)
+      host = configuration[:host] || 'photon.komoot.io'
+      method = query.reverse_geocode? ? 'reverse' : 'api'
+      "#{protocol}://#{host}/#{method}?"
+    end
+
+    def results(query)
+      return [] unless (doc = fetch_data(query))
+      return [] unless doc['type'] == 'FeatureCollection'
+      return [] unless doc['features'] || doc['features'].present?
+
+      doc['features']
+    end
+
+    def query_url_params(query)
+      lang = query.language || configuration.language
+      params = { lang: lang, limit: query.options[:limit] }
+
+      if query.reverse_geocode?
+        params.merge!(query_url_params_reverse(query))
+      else
+        params.merge!(query_url_params_coordinates(query))
+      end
+
+      params.merge!(super)
+    end
+
+    def query_url_params_coordinates(query)
+      params = { q: query.sanitized_text }
+
+      if (bias = query.options[:bias])
+        params.merge!(lat: bias[:latitude], lon: bias[:longitude], location_bias_scale: bias[:scale])
+      end
+
+      if (filter = query_url_params_coordinates_filter(query))
+        params.merge!(filter)
+      end
+
+      params
+    end
+
+    def query_url_params_coordinates_filter(query)
+      filter = query.options[:filter]
+      return unless filter
+
+      bbox = filter[:bbox]
+      {
+        bbox: bbox.is_a?(Array) ? bbox.join(',') : bbox,
+        osm_tag: filter[:osm_tag]
+      }
+    end
+
+    def query_url_params_reverse(query)
+      params = { lat: query.coordinates[0], lon: query.coordinates[1], radius: query.options[:radius] }
+
+      if (dsort = query.options[:distance_sort])
+        params[:distance_sort] = dsort ? 'true' : 'false'
+      end
+
+      if (filter = query_url_params_reverse_filter(query))
+        params.merge!(filter)
+      end
+
+      params
+    end
+
+    def query_url_params_reverse_filter(query)
+      filter = query.options[:filter]
+      return unless filter
+
+      { query_string_filter: filter[:string] }
+    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
@@ -39,7 +57,12 @@ module Geocoder::Lookup
     end
 
     def results(query)
-      fetch_data(query) || []
+      doc = fetch_data(query) || []
+      if doc.is_a?(Hash) and doc.key?('status') # implies there's an error
+        return []
+      else
+        return doc
+      end
     end
   end
 end

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.rapidapi.com/location/#{query.sanitized_text}?rapidapi-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

data/lib/geocoder/lookups/test.rb

@@ -18,6 +18,7 @@ module Geocoder
       end
 
       def self.read_stub(query_text)
+        @default_stub ||= nil
         stubs.fetch(query_text) {
           return @default_stub unless @default_stub.nil?
           raise ArgumentError, "unknown stub request #{query_text}"
@@ -28,6 +29,10 @@ module Geocoder
         @stubs ||= {}
       end
 
+      def self.delete_stub(query_text)
+        stubs.delete(query_text)
+      end
+
       def self.reset
         @stubs = {}
         @default_stub = nil

data/lib/geocoder/lookups/twogis.rb

@@ -0,0 +1,58 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/twogis"
+
+module Geocoder::Lookup
+  class Twogis < Base
+
+    def name
+      "2gis"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def map_link_url(coordinates)
+      "https://2gis.ru/?m=#{coordinates.join(',')}"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://catalog.api.2gis.com/3.0/items/geocode?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc['meta'] && doc['meta']['error']
+        Geocoder.log(:warn, "2gis Geocoding API error: #{doc['meta']["code"]} (#{doc['meta']['error']["message"]}).")
+        return []
+      end
+      if doc['result'] && doc = doc['result']['items']
+        return doc.to_a
+      else
+        Geocoder.log(:warn, "2gis Geocoding API error: unexpected response format.")
+        return []
+      end
+    end
+
+    def query_url_params(query)
+      if query.reverse_geocode?
+        q = query.coordinates.reverse.join(",")
+      else
+        q = query.sanitized_text
+      end
+      params = {
+        :q => q,
+        :lang => "#{query.language || configuration.language}",
+        :key => configuration.api_key,
+        :fields => 'items.street,items.adm_div,items.full_address_name,items.point,items.geometry.centroid'
+      }
+      params.merge(super)
+    end
+  end
+end