geocoder 1.6.6 → 1.7.2

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

@@ -9,7 +9,7 @@ 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
+  # cache_prefix: 'geocoder:',  # DEPRECATED, please use cache_options[:prefix] instead
 
   # Exceptions that should not be rescued by default
   # (if you want to implement custom error handling);
@@ -19,4 +19,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,23 +1,18 @@
+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 = (Object.const_get("Geocoder::CacheStore::#{store.class}") 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
       warn "Geocoder cache read error: #{e}"
     end
@@ -26,14 +21,7 @@ module Geocoder
     # 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
       warn "Geocoder cache write error: #{e}"
     end
@@ -44,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")
@@ -57,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
 
     ##
@@ -91,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,6 +55,7 @@ module Geocoder
       :lookup,
       :ip_lookup,
       :language,
+      :host,
       :http_headers,
       :use_https,
       :http_proxy,
@@ -67,7 +68,8 @@ module Geocoder
       :distances,
       :basic_auth,
       :logger,
-      :kernel_logger_level
+      :kernel_logger_level,
+      :cache_options
     ]
 
     attr_accessor :data
@@ -107,7 +109,7 @@ module Geocoder
       @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[:cache_prefix] = "geocoder:" # - DEPRECATED - 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 +122,9 @@ module Geocoder
       # calculation options
       @data[:units]     = :mi      # :mi or :km
       @data[:distances] = :linear  # :linear or :spherical
+
+      # explicit cache service options
+      @data[:cache_options] = {}
     end
 
     instance_eval(OPTIONS.map do |option|

data/lib/geocoder/ip_address.rb

@@ -7,6 +7,12 @@ 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)
+
+      super(ip)
+    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,11 @@ module Geocoder
         :test,
         :latlon,
         :amap,
-        :osmnames
+        :osmnames,
+        :melissa_street,
+        :amazon_location_service,
+        :geoapify,
+        :photon
       ]
     end
 
@@ -63,6 +75,7 @@ module Geocoder
     def ip_services
       @ip_services ||= [
         :baidu_ip,
+        :abstract_api,
         :freegeoip,
         :geoip2,
         :maxmind,
@@ -77,7 +90,8 @@ module Geocoder
         :db_ip_com,
         :ipstack,
         :ip2location,
-        :ipgeolocation
+        :ipgeolocation,
+        :ipqualityscore
       ]
     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/amazon_location_service.rb

@@ -0,0 +1,54 @@
+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(
+          access_key_id: keys[:access_key_id],
+          secret_access_key: keys[:secret_access_key],
+        )
+      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/base.rb

@@ -83,8 +83,14 @@ module Geocoder
       # The working Cache object.
       #
       def cache
-        if @cache.nil? and store = configuration.cache
-          @cache = Cache.new(store, configuration.cache_prefix)
+        if @cache.nil? && (store = configuration.cache)
+          cache_options = configuration.cache_options
+          cache_prefix = (configuration.cache_prefix rescue false)
+          if cache_prefix
+            cache_options[:prefix] ||= configuration.cache_prefix
+            warn '[Geocoder] cache_prefix is deprecated, please change to cache_options.prefix instead'
+          end
+          @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/geoapify.rb

@@ -0,0 +1,72 @@
+# 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 = query.reverse_geocode? ? 'reverse' : 'search'
+        "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

data/lib/geocoder/lookups/geoip2.rb

@@ -37,6 +37,10 @@ module Geocoder
       def results(query)
         return [] unless configuration[:file]
 
+        if @mmdb.respond_to?(:local_ip_alias) && !configuration[:local_ip_alias].nil?
+          @mmdb.local_ip_alias = configuration[:local_ip_alias]
+        end
+
         result = @mmdb.lookup(query.to_s)
         result.nil? ? [] : [result]
       end

data/lib/geocoder/lookups/ip2location.rb

@@ -8,6 +8,10 @@ module Geocoder::Lookup
       "IP2LocationApi"
     end
 
+    def required_api_key_parts
+      ['key']
+    end
+
     def supported_protocols
       [:http, :https]
     end
@@ -15,15 +19,15 @@ module Geocoder::Lookup
     private # ----------------------------------------------------------------
 
     def base_query_url(query)
-      "#{protocol}://api.ip2location.com/?"
+      "#{protocol}://api.ip2location.com/v2/?"
     end
 
     def query_url_params(query)
-      params = super
-      if configuration.has_key?(:package)
-        params.merge!(package: configuration[:package])
-      end
-      params
+      super.merge(
+        key: configuration.api_key,
+        ip: query.sanitized_text,
+        package: configuration[:package],
+      )
     end
 
     def results(query)

data/lib/geocoder/lookups/ipdata_co.rb

@@ -47,7 +47,7 @@ module Geocoder::Lookup
     end
 
     def host
-      "api.ipdata.co"
+      configuration[:host] || "api.ipdata.co"
     end
 
     def check_response_for_errors!(response)

data/lib/geocoder/lookups/ipqualityscore.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/ipqualityscore'
+
+module Geocoder::Lookup
+  class Ipqualityscore < Base
+
+    def name
+      "IPQualityScore"
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://ipqualityscore.com/api/json/ip/#{configuration.api_key}/#{query.sanitized_text}?"
+    end
+
+    def valid_response?(response)
+      if (json = parse_json(response.body))
+        success = json['success']
+      end
+      super && success == true
+    end
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+
+      return [doc] if doc['success']
+
+      case doc['message']
+      when /invalid (.*) key/i
+        raise_error Geocoder::InvalidApiKey ||
+                    Geocoder.log(:warn, "#{name} API error: invalid api key.")
+      when /insufficient credits/, /exceeded your request quota/
+        raise_error Geocoder::OverQueryLimitError ||
+                    Geocoder.log(:warn, "#{name} API error: query limit exceeded.")
+      when /invalid (.*) address/i
+        raise_error Geocoder::InvalidRequest ||
+                    Geocoder.log(:warn, "#{name} API error: invalid request.")
+      end
+
+      [doc]
+    end
+  end
+end

data/lib/geocoder/lookups/melissa_street.rb

@@ -0,0 +1,41 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/melissa_street"
+
+module Geocoder::Lookup
+  class MelissaStreet < Base
+
+    def name
+      "MelissaStreet"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if doc["TransmissionResults"] == "GE05"
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "Melissa service error: invalid API key.")
+      end
+
+      return doc["Records"]
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://address.melissadata.net/v3/WEB/GlobalAddress/doGlobalAddress?"
+    end
+
+    def query_url_params(query)
+      params = {
+        id: configuration.api_key,
+        format: "JSON",
+        a1: query.sanitized_text,
+        loc: query.options[:city],
+        admarea: query.options[:state],
+        postal: query.options[:postal],
+        ctry: query.options[:country]
+      }
+      params.merge(super)
+    end
+  end
+end