geocoder 1.6.4 → 1.8.2

data/examples/app_defined_lookup_services.rb

@@ -0,0 +1,22 @@
+# To extend the Geocoder with additional lookups that come from the application,
+# not shipped with the gem, define a "child" lookup in your application, based on existing one.
+# This is required because the Geocoder::Configuration is a Singleton and stores one api key per lookup.
+
+# in app/libs/geocoder/lookup/my_preciousss.rb
+module Geocoder::Lookup
+  class MyPreciousss < Google
+  end
+end
+
+# Update Geocoder's street_services on initialize:
+# config/initializers/geocoder.rb
+Geocoder::Lookup.street_services << :my_preciousss
+
+# Override the configuration when necessary (e.g. provide separate Google API key for the account):
+Geocoder.configure(my_preciousss: { api_key: 'abcdef' })
+
+# Lastly, search using your custom lookup service/api keys
+Geocoder.search("Paris", lookup: :my_preciousss)
+
+# This is useful when we have groups of users in the application who use Google paid services
+# and we want to properly separate them and allow using individual API KEYS or timeouts.

data/lib/generators/geocoder/config/templates/initializer.rb

@@ -9,7 +9,6 @@ Geocoder.configure(
   # https_proxy: nil,           # HTTPS proxy server (user:pass@host:port)
   # api_key: nil,               # API key for geocoding service
   # cache: nil,                 # cache object (must respond to #[], #[]=, and #del)
-  # cache_prefix: 'geocoder:',  # prefix (string) to use for all cache keys
 
   # Exceptions that should not be rescued by default
   # (if you want to implement custom error handling);
@@ -19,4 +18,10 @@ Geocoder.configure(
   # Calculation options
   # units: :mi,                 # :km for kilometers or :mi for miles
   # distances: :linear          # :spherical or :linear
+
+  # Cache configuration
+  # cache_options: {
+  #   expiration: 2.days,
+  #   prefix: 'geocoder:'
+  # }
 )

data/lib/geocoder/cache.rb

@@ -1,37 +1,29 @@
+Dir["#{__dir__}/cache_stores/*.rb"].each {|file| require file }
+
 module Geocoder
   class Cache
 
-    def initialize(store, prefix)
-      @store = store
-      @prefix = prefix
+    def initialize(store, config)
+      @class = (Geocoder::CacheStore.const_get("#{store.class}", false) rescue Geocoder::CacheStore::Generic)
+      @store_service = @class.new(store, config)
     end
 
     ##
     # Read from the Cache.
     #
     def [](url)
-      interpret case
-        when store.respond_to?(:[])
-          store[key_for(url)]
-        when store.respond_to?(:get)
-          store.get key_for(url)
-        when store.respond_to?(:read)
-          store.read key_for(url)
-      end
+      interpret store_service.read(url)
+    rescue => e
+      Geocoder.log(:warn, "Geocoder cache read error: #{e}")
     end
 
     ##
     # Write to the Cache.
     #
     def []=(url, value)
-      case
-        when store.respond_to?(:[]=)
-          store[key_for(url)] = value
-        when store.respond_to?(:set)
-          store.set key_for(url), value
-        when store.respond_to?(:write)
-          store.write key_for(url), value
-      end
+      store_service.write(url, value)
+    rescue => e
+      Geocoder.log(:warn, "Geocoder cache write error: #{e}")
     end
 
     ##
@@ -40,7 +32,7 @@ module Geocoder
     #
     def expire(url)
       if url == :all
-        if store.respond_to?(:keys)
+        if store_service.respond_to?(:keys)
           urls.each{ |u| expire(u) }
         else
           raise(NoMethodError, "The Geocoder cache store must implement `#keys` for `expire(:all)` to work")
@@ -53,29 +45,21 @@ module Geocoder
 
     private # ----------------------------------------------------------------
 
-    def prefix; @prefix; end
-    def store; @store; end
-
-    ##
-    # Cache key for a given URL.
-    #
-    def key_for(url)
-      [prefix, url].join
-    end
+    def store_service; @store_service; end
 
     ##
     # Array of keys with the currently configured prefix
     # that have non-nil values.
     #
     def keys
-      store.keys.select{ |k| k.match(/^#{prefix}/) and self[k] }
+      store_service.keys
     end
 
     ##
     # Array of cached URLs.
     #
     def urls
-      keys.map{ |k| k[/^#{prefix}(.*)/, 1] }
+      store_service.urls
     end
 
     ##
@@ -87,8 +71,7 @@ module Geocoder
     end
 
     def expire_single_url(url)
-      key = key_for(url)
-      store.respond_to?(:del) ? store.del(key) : store.delete(key)
+      store_service.remove(url)
     end
   end
 end

data/lib/geocoder/cache_stores/base.rb

@@ -0,0 +1,40 @@
+module Geocoder::CacheStore
+  class Base
+    def initialize(store, options)
+      @store = store
+      @config = options
+      @prefix = config[:prefix]
+    end
+
+    ##
+    # Array of keys with the currently configured prefix
+    # that have non-nil values.
+    def keys
+      store.keys.select { |k| k.match(/^#{prefix}/) and self[k] }
+    end
+
+    ##
+    # Array of cached URLs.
+    #
+    def urls
+      keys
+    end
+
+    protected # ----------------------------------------------------------------
+
+    def prefix; @prefix; end
+    def store; @store; end
+    def config; @config; end
+
+    ##
+    # Cache key for a given URL.
+    #
+    def key_for(url)
+      if url.match(/^#{prefix}/)
+        url
+      else
+        [prefix, url].join
+      end
+    end
+  end
+end

data/lib/geocoder/cache_stores/generic.rb

@@ -0,0 +1,35 @@
+require 'geocoder/cache_stores/base'
+
+module Geocoder::CacheStore
+  class Generic < Base
+    def write(url, value)
+      case
+      when store.respond_to?(:[]=)
+        store[key_for(url)] = value
+      when store.respond_to?(:set)
+        store.set key_for(url), value
+      when store.respond_to?(:write)
+        store.write key_for(url), value
+      end
+    end
+
+    def read(url)
+      case
+      when store.respond_to?(:[])
+        store[key_for(url)]
+      when store.respond_to?(:get)
+        store.get key_for(url)
+      when store.respond_to?(:read)
+        store.read key_for(url)
+      end
+    end
+
+    def keys
+      store.keys
+    end
+
+    def remove(key)
+      store.delete(key)
+    end
+  end
+end

data/lib/geocoder/cache_stores/redis.rb

@@ -0,0 +1,34 @@
+require 'geocoder/cache_stores/base'
+
+module Geocoder::CacheStore
+  class Redis < Base
+    def initialize(store, options)
+      super
+      @expiration = options[:expiration]
+    end
+
+    def write(url, value, expire = @expiration)
+      if expire.present?
+        store.set key_for(url), value, ex: expire
+      else
+        store.set key_for(url), value
+      end
+    end
+
+    def read(url)
+      store.get key_for(url)
+    end
+
+    def keys
+      store.keys("#{prefix}*")
+    end
+
+    def remove(key)
+      store.del(key)
+    end
+
+    private # ----------------------------------------------------------------
+
+    def expire; @expiration; end
+  end
+end

data/lib/geocoder/configuration.rb

@@ -55,19 +55,20 @@ module Geocoder
       :lookup,
       :ip_lookup,
       :language,
+      :host,
       :http_headers,
       :use_https,
       :http_proxy,
       :https_proxy,
       :api_key,
       :cache,
-      :cache_prefix,
       :always_raise,
       :units,
       :distances,
       :basic_auth,
       :logger,
-      :kernel_logger_level
+      :kernel_logger_level,
+      :cache_options
     ]
 
     attr_accessor :data
@@ -76,6 +77,10 @@ module Geocoder
       instance.set_defaults
     end
 
+    def self.initialize
+      instance.send(:initialize)
+    end
+
     OPTIONS.each do |o|
       define_method o do
         @data[o]
@@ -106,8 +111,6 @@ module Geocoder
       @data[:http_proxy]   = nil         # HTTP proxy server (user:pass@host:port)
       @data[:https_proxy]  = nil         # HTTPS proxy server (user:pass@host:port)
       @data[:api_key]      = nil         # API key for geocoding service
-      @data[:cache]        = nil         # cache object (must respond to #[], #[]=, and #keys)
-      @data[:cache_prefix] = "geocoder:" # prefix (string) to use for all cache keys
       @data[:basic_auth]   = {}          # user and password for basic auth ({:user => "user", :password => "password"})
       @data[:logger]       = :kernel     # :kernel or Logger instance
       @data[:kernel_logger_level] = ::Logger::WARN # log level, if kernel logger is used
@@ -120,6 +123,16 @@ module Geocoder
       # calculation options
       @data[:units]     = :mi      # :mi or :km
       @data[:distances] = :linear  # :linear or :spherical
+
+      # Set the default values for the caching mechanism
+      # By default, the cache keys will not expire as IP addresses and phyiscal
+      # addresses will rarely change.
+      @data[:cache]        = nil   # cache object (must respond to #[], #[]=, and optionally #keys)
+      @data[:cache_prefix] = nil   # - DEPRECATED - prefix (string) to use for all cache keys
+      @data[:cache_options] = {
+        prefix: 'geocoder:',
+        expiration: nil
+      }
     end
 
     instance_eval(OPTIONS.map do |option|

data/lib/geocoder/ip_address.rb

@@ -7,6 +7,15 @@ module Geocoder
       '192.168.0.0/16',
     ].map { |ip| IPAddr.new(ip) }.freeze
 
+    def initialize(ip)
+      ip = ip.to_string if ip.is_a?(IPAddr)
+      if ip.is_a?(Hash)
+        super(**ip)
+      else
+        super(ip)
+      end
+    end
+
     def internal?
       loopback? || private?
     end

data/lib/geocoder/lookup.rb

@@ -18,6 +18,14 @@ module Geocoder
       all_services - [:test]
     end
 
+    ##
+    # Array of valid Lookup service names, excluding any that do not build their own HTTP requests.
+    # For example, Amazon Location Service uses the AWS gem, not HTTP REST requests, to fetch data.
+    #
+    def all_services_with_http_requests
+      all_services_except_test - [:amazon_location_service]
+    end
+
     ##
     # All street address lookup services, default first.
     #
@@ -53,7 +61,13 @@ module Geocoder
         :test,
         :latlon,
         :amap,
-        :osmnames
+        :osmnames,
+        :melissa_street,
+        :amazon_location_service,
+        :geoapify,
+        :photon,
+        :twogis,
+        :pc_miler
       ]
     end
 
@@ -63,6 +77,7 @@ module Geocoder
     def ip_services
       @ip_services ||= [
         :baidu_ip,
+        :abstract_api,
         :freegeoip,
         :geoip2,
         :maxmind,
@@ -77,7 +92,9 @@ module Geocoder
         :db_ip_com,
         :ipstack,
         :ip2location,
-        :ipgeolocation
+        :ipgeolocation,
+        :ipqualityscore,
+        :ipbase
       ]
     end
 
@@ -103,8 +120,7 @@ module Geocoder
     def spawn(name)
       if all_services.include?(name)
         name = name.to_s
-        require "geocoder/lookups/#{name}"
-        Geocoder::Lookup.const_get(classify_name(name)).new
+        instantiate_lookup(name)
       else
         valids = all_services.map(&:inspect).join(", ")
         raise ConfigurationError, "Please specify a valid lookup for Geocoder " +
@@ -118,5 +134,18 @@ module Geocoder
     def classify_name(filename)
       filename.to_s.split("_").map{ |i| i[0...1].upcase + i[1..-1] }.join
     end
+
+    ##
+    # Safely instantiate Lookup
+    #
+    def instantiate_lookup(name)
+      class_name = classify_name(name)
+      begin
+        Geocoder::Lookup.const_get(class_name, inherit=false)
+      rescue NameError
+        require "geocoder/lookups/#{name}"
+      end
+      Geocoder::Lookup.const_get(class_name).new
+    end
   end
 end

data/lib/geocoder/lookups/abstract_api.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/abstract_api'
+
+module Geocoder::Lookup
+  class AbstractApi < Base
+
+    def name
+      "Abstract API"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipgeolocation.abstractapi.com/v1/?"
+    end
+
+    def query_url_params(query)
+      params = {api_key: configuration.api_key}
+
+      ip_address = query.sanitized_text
+      if ip_address.is_a?(String) && ip_address.length > 0
+        params[:ip_address] = ip_address
+      end
+
+      params.merge(super)
+    end
+
+    def results(query, reverse = false)
+      if doc = fetch_data(query)
+        [doc]
+      else
+        []
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/amap.rb

@@ -32,10 +32,10 @@ module Geocoder::Lookup
         return doc['geocodes'] unless doc['geocodes'].blank?
       when ['0', 'INVALID_USER_KEY']
         raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
-          warn("#{self.name} Geocoding API error: invalid api key.")
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: invalid api key.")
       else
         raise_error(Geocoder::Error, "server error.") ||
-          warn("#{self.name} Geocoding API error: server error - [#{doc['info']}]")
+          Geocoder.log(:warn, "#{self.name} Geocoding API error: server error - [#{doc['info']}]")
       end
       return []
     end

data/lib/geocoder/lookups/amazon_location_service.rb

@@ -0,0 +1,55 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/amazon_location_service'
+
+module Geocoder::Lookup
+  class AmazonLocationService < Base
+    def results(query)
+      params = query.options.dup
+
+      # index_name is required
+      # Aws::ParamValidator raises ArgumentError on missing required keys
+      params.merge!(index_name: configuration[:index_name])
+
+      # Aws::ParamValidator raises ArgumentError on unexpected keys
+      params.delete(:lookup) 
+      
+      resp = if query.reverse_geocode?
+        client.search_place_index_for_position(params.merge(position: query.coordinates.reverse))
+      else
+        client.search_place_index_for_text(params.merge(text: query.text))
+      end
+      
+      resp.results.map(&:place)
+    end
+
+    private
+
+    def client
+      return @client if @client
+      require_sdk
+      keys = configuration.api_key
+      if keys
+        @client = Aws::LocationService::Client.new(**{
+          region: keys[:region],
+          access_key_id: keys[:access_key_id],
+          secret_access_key: keys[:secret_access_key]
+        }.compact)
+      else
+        @client = Aws::LocationService::Client.new
+      end
+    end
+
+    def require_sdk
+      begin
+        require 'aws-sdk-locationservice'
+      rescue LoadError
+        raise_error(Geocoder::ConfigurationError) ||
+          Geocoder.log(
+            :error,
+            "Couldn't load the Amazon Location Service SDK. " +
+            "Install it with: gem install aws-sdk-locationservice -v '~> 1.4'"
+          )
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/ban_data_gouv_fr.rb

@@ -125,7 +125,7 @@ module Geocoder::Lookup
     end
 
     def type_param_is_valid?(param)
-      %w(housenumber street locality village town city).include?(param.downcase)
+      %w(housenumber street locality municipality).include?(param.downcase)
     end
 
     def code_param_is_valid?(param)

data/lib/geocoder/lookups/base.rb

@@ -84,7 +84,8 @@ module Geocoder
       #
       def cache
         if @cache.nil? and store = configuration.cache
-          @cache = Cache.new(store, configuration.cache_prefix)
+          cache_options = configuration.cache_options
+          @cache = Cache.new(store, cache_options)
         end
         @cache
       end

data/lib/geocoder/lookups/bing.rb

@@ -54,7 +54,7 @@ module Geocoder::Lookup
     def query_url_params(query)
       {
         key: configuration.api_key,
-        language: (query.language || configuration.language)
+        culture: (query.language || configuration.language)
       }.merge(super)
     end
 

data/lib/geocoder/lookups/esri.rb

@@ -23,15 +23,28 @@ module Geocoder::Lookup
     def results(query)
       return [] unless doc = fetch_data(query)
 
-      if (!query.reverse_geocode?)
-        return [] if !doc['locations'] || doc['locations'].empty?
-      end
-
       if (doc['error'].nil?)
+        if (!query.reverse_geocode?)
+          return [] if !doc['locations'] || doc['locations'].empty?
+        end
         return [ doc ]
       else
-        return []
+        case [ doc['error']['code'] ]
+        when [498]
+          raise_error(Geocoder::InvalidApiKey, doc['error']['message']) ||
+            Geocoder.log(:warn, "#{self.name} Geocoding API error: #{doc['error']['message']}")
+        when [ 403 ]
+          raise_error(Geocoder::RequestDenied, 'ESRI request denied') ||
+            Geocoder.log(:warn, "#{self.name} ESRI request denied: #{doc['error']['message']}")
+        when [ 500 ], [501]
+          raise_error(Geocoder::ServiceUnavailable, 'ESRI service unavailable') ||
+            Geocoder.log(:warn, "#{self.name} ESRI service error: #{doc['error']['message']}")
+        else
+          raise_error(Geocoder::Error, doc['error']['message']) ||
+            Geocoder.log(:warn, "#{self.name} Geocoding error: #{doc['error']['message']}")
+        end
       end
+      return []
     end
 
     def query_url_params(query)

data/lib/geocoder/lookups/freegeoip.rb

@@ -17,14 +17,16 @@ module Geocoder::Lookup
       end
     end
 
-    def query_url(query)
-      "#{protocol}://#{host}/json/#{query.sanitized_text}"
-    end
-
     private # ---------------------------------------------------------------
 
-    def cache_key(query)
-      query_url(query)
+    def base_query_url(query)
+      "#{protocol}://#{host}/json/#{query.sanitized_text}?"
+    end
+
+    def query_url_params(query)
+      {
+        :apikey => configuration.api_key
+      }.merge(super)
     end
 
     def parse_raw_data(raw_data)

data/lib/geocoder/lookups/geoapify.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/geoapify'
+
+module Geocoder
+  module Lookup
+    # https://apidocs.geoapify.com/docs/geocoding/api
+    class Geoapify < Base
+      def name
+        'Geoapify'
+      end
+
+      def required_api_key_parts
+        ['api_key']
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def base_query_url(query)
+        method = if query.reverse_geocode?
+          'reverse'
+        elsif query.options[:autocomplete]
+          'autocomplete'
+        else
+          'search'
+        end
+        "https://api.geoapify.com/v1/geocode/#{method}?"
+      end
+
+      def results(query)
+        return [] unless (doc = fetch_data(query))
+
+        # The rest of the status codes should be already handled by the default
+        # functionality as the API returns correct HTTP response codes in most
+        # cases. There may be some unhandled cases still (such as over query
+        # limit reached) but there is not enough documentation to cover them.
+        case doc['statusCode']
+        when 500
+          raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, doc['message'])
+        end
+
+        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 = { apiKey: configuration.api_key, 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)
+        { text: query.sanitized_text }
+      end
+
+      def query_url_params_reverse(query)
+        {
+          lat: query.coordinates[0],
+          lon: query.coordinates[1]
+        }
+      end
+    end
+  end
+end