geocoder 1.5.1 → 1.8.5

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/pdok_nl.rb

@@ -0,0 +1,43 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/pdok_nl"
+
+module Geocoder::Lookup
+  class PdokNl < Base
+
+    def name
+      'pdok NL'
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def cache_key(query)
+      base_query_url(query) + hash_to_query(query_url_params(query))
+    end
+
+    def base_query_url(query)
+      "#{protocol}://api.pdok.nl/bzk/locatieserver/search/v3_1/free?"
+    end
+
+    def valid_response?(response)
+      json   = parse_json(response.body)
+      super(response) if json
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc['response']['docs']
+    end
+
+    def query_url_params(query)
+      {
+        fl: '*',
+        q:  query.text,
+        wt: 'json'
+      }.merge(super)
+    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
+      [:http, :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

@@ -23,7 +23,7 @@ module Geocoder::Lookup
     end
 
     def query_url_params(query)
-      params = {
+      {
         key: configuration.api_key
       }.merge(super)
     end

data/lib/geocoder/lookups/smarty_streets.rb

@@ -57,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

@@ -16,7 +16,7 @@ module Geocoder::Lookup
       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}"
+        "#{protocol}://telize-v1.p.rapidapi.com/location/#{query.sanitized_text}?rapidapi-key=#{api_key}"
       end
     end
 

data/lib/geocoder/lookups/tencent.rb

@@ -31,18 +31,18 @@ module Geocoder::Lookup
       case doc['status']
       when 0
         return [doc[content_key]]
-      when 199
-        raise error(Geocoder::InvalidApiKey, "invalid api key") ||
-        Geocoder.log(:warn, "#{name} Geocoding API error: key is not enabled for web service usage.")
-      when 311
-        raise_error(Geocoder::RequestDenied, "request denied") ||
-          Geocoder.log(:warn, "#{name} Geocoding API error: request denied.")
-      when 310, 306
-        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
-          Geocoder.log(:warn, "#{name} Geocoding API error: invalid request.")
       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

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

data/lib/geocoder/lookups/uk_ordnance_survey_names.rb

@@ -0,0 +1,59 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/uk_ordnance_survey_names'
+
+module Geocoder::Lookup
+  class UkOrdnanceSurveyNames < Base
+
+    def name
+      'Ordance Survey Names'
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def base_query_url(query)
+      "#{protocol}://api.os.uk/search/names/v1/find?"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      base_query_url(query) + url_query_string(query)
+    end
+
+    private # -------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] if doc['header']['totalresults'].zero?
+      return doc['results'].map { |r| r['GAZETTEER_ENTRY'] }
+    end
+
+    def query_url_params(query)
+      {
+        query: query.sanitized_text,
+        key: configuration.api_key,
+        fq: filter
+      }.merge(super)
+    end
+
+    def local_types
+      %w[
+        City
+        Hamlet
+        Other_Settlement
+        Town
+        Village
+        Postcode
+      ]
+    end
+
+    def filter
+      local_types.map { |t| "local_type:#{t}" }.join(' ')
+    end
+
+  end
+end

data/lib/geocoder/lookups/yandex.rb

@@ -24,17 +24,16 @@ module Geocoder::Lookup
 
     def results(query)
       return [] unless doc = fetch_data(query)
-      if err = doc['error']
-        if err["status"] == 401 and err["message"] == "invalid key"
+      if [400, 403].include? doc['statusCode']
+        if doc['statusCode'] == 403 and doc['message'] == 'Invalid key'
           raise_error(Geocoder::InvalidApiKey) || Geocoder.log(:warn, "Invalid API key.")
         else
-          Geocoder.log(:warn, "Yandex Geocoding API error: #{err['status']} (#{err['message']}).")
+          Geocoder.log(:warn, "Yandex Geocoding API error: #{doc['statusCode']} (#{doc['message']}).")
         end
         return []
       end
       if doc = doc['response']['GeoObjectCollection']
-        meta = doc['metaDataProperty']['GeocoderResponseMetaData']
-        return meta['found'].to_i > 0 ? doc['featureMember'] : []
+        return doc['featureMember'].to_a
       else
         Geocoder.log(:warn, "Yandex Geocoding API error: unexpected response format.")
         return []
@@ -50,8 +49,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('~')

data/lib/geocoder/query.rb

@@ -23,7 +23,7 @@ module Geocoder
           text.split(/\s*,\s*/).join(',')
         end
       else
-        text
+        text.to_s.strip
       end
     end
 

data/lib/geocoder/results/abstract_api.rb

@@ -0,0 +1,146 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class AbstractApi < Base
+
+      ##
+      # Geolocation
+
+      def state
+        @data['region']
+      end
+
+      def state_code
+        @data['region_iso_code']
+      end
+
+      def city
+        @data["city"]
+      end
+
+      def city_geoname_id
+        @data["city_geoname_id"]
+      end
+
+      def region_geoname_id
+        @data["region_geoname_id"]
+      end
+
+      def postal_code
+        @data["postal_code"]
+      end
+
+      def country
+        @data["country"]
+      end
+
+      def country_code
+        @data["country_code"]
+      end
+
+      def country_geoname_id
+        @data["country_geoname_id"]
+      end
+
+      def country_is_eu
+        @data["country_is_eu"]
+      end
+
+      def continent
+        @data["continent"]
+      end
+
+      def continent_code
+        @data["continent_code"]
+      end
+
+      def continent_geoname_id
+        @data["continent_geoname_id"]
+      end
+
+      ##
+      # Security
+
+      def is_vpn?
+        @data.dig "security", "is_vpn"
+      end
+
+      ##
+      # Timezone
+
+      def timezone_name
+        @data.dig "timezone", "name"
+      end
+
+      def timezone_abbreviation
+        @data.dig "timezone", "abbreviation"
+      end
+
+      def timezone_gmt_offset
+        @data.dig "timezone", "gmt_offset"
+      end
+
+      def timezone_current_time
+        @data.dig "timezone", "current_time"
+      end
+
+      def timezone_is_dst
+        @data.dig "timezone", "is_dst"
+      end
+
+      ##
+      # Flag
+
+      def flag_emoji
+        @data.dig "flag", "emoji"
+      end
+
+      def flag_unicode
+        @data.dig "flag", "unicode"
+      end
+
+      def flag_png
+        @data.dig "flag", "png"
+      end
+
+      def flag_svg
+        @data.dig "flag", "svg"
+      end
+
+      ##
+      # Currency
+
+      def currency_currency_name
+        @data.dig "currency", "currency_name"
+      end
+
+      def currency_currency_code
+        @data.dig "currency", "currency_code"
+      end
+
+      ##
+      # Connection
+
+      def connection_autonomous_system_number
+        @data.dig "connection", "autonomous_system_number"
+      end
+
+      def connection_autonomous_system_organization
+        @data.dig "connection", "autonomous_system_organization"
+      end
+
+      def connection_connection_type
+        @data.dig "connection", "connection_type"
+      end
+
+      def connection_isp_name
+        @data.dig "connection", "isp_name"
+      end
+
+      def connection_organization_name
+        @data.dig "connection", "organization_name"
+      end
+    end
+  end
+end

data/lib/geocoder/results/amazon_location_service.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class AmazonLocationService < Base
+    def initialize(result)
+      @place = result.place
+      super
+    end
+
+    def coordinates
+      [@place.geometry.point[1], @place.geometry.point[0]]
+    end
+
+    def address
+      @place.label
+    end
+
+    def neighborhood
+      @place.neighborhood
+    end
+
+    def route
+      @place.street
+    end
+
+    def city
+      @place.municipality || @place.sub_region
+    end
+
+    def state
+      @place.region
+    end
+
+    def state_code
+      @place.region
+    end
+
+    def province
+      @place.region
+    end
+
+    def province_code
+      @place.region
+    end
+
+    def postal_code
+      @place.postal_code
+    end
+
+    def country
+      @place.country
+    end
+
+    def country_code
+      @place.country
+    end
+
+    def place_id
+      data.place_id if data.respond_to?(:place_id)
+    end
+  end
+end