geocoder 1.7.2 → 1.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dd61064f277184f4cd323f881e949513dbd29707f9b5975e1da0ef6717536a1
-  data.tar.gz: efc08471c7d346d9355e3cd19483aa8a46acd83216678023da6b3b9535844d9a
+  metadata.gz: 5063f6ec31c36d023439cdb255c76f62e9107da4d3bd42667a0f8a1df12919fd
+  data.tar.gz: d260cd1d770947fa7415989c63404bb0f0e179eee7a0e0e09c3e5c56b019dec2
 SHA512:
-  metadata.gz: 8a9517555ad1f9ba13f401ffda9dc2b2b011af207520c062c048f78d0dbdbc44bf1a8a5293237a41a640f45ba065ead82e666c738b828a78756d1e9dd93a9a0c
-  data.tar.gz: ee14868f649772f74293aa27f84f6355bafdfe7e71429bf5624ac32998d189e01acb09d3931fe36c43c9e7c5c8df494d71364fa0ec6c8f51d19f87780b394684
+  metadata.gz: dd798ea9317b6cbdc51b521c60558002fc4263adb52fd2de8277e834a03a04561cedc070e2d08f4fe9ebd688771a8f6440a9c9288a83b6d3412d3d100714a99f
+  data.tar.gz: d262213ca0f637847d571d81054365e969c6eb6b3444e6064a538928a0fb673c5e7c315bc0708758c33e107d46bf38a642f91bccb574273e0c784c77cf8562ad

data/CHANGELOG.md

@@ -3,6 +3,19 @@ Changelog
 
 Major changes to Geocoder for each release. Please see the Git log for complete list of changes.
 
+1.7.5 (2022 Mar 14)
+-------------------
+* Avoid lookup naming collisions in some environments.
+
+1.7.4 (2022 Mar 14)
+-------------------
+* Add ability to use app-defined lookups (thanks github.com/januszm).
+* Updates to LocationIQ and FreeGeoIP lookups.
+
+1.7.3 (2022 Jan 17)
+-------------------
+* Get rid of unnecessary cache_prefix deprecation warnings.
+
 1.7.2 (2022 Jan  2)
 -------------------
 * Fix uninitialized constant error (occurring on some systems with v1.7.1).

data/README.md

@@ -20,7 +20,7 @@ Compatibility:
 
 * Ruby versions: 2.1+, and JRuby.
 * Databases: MySQL, PostgreSQL, SQLite, and MongoDB.
-* Rails: 5.x and 6.x.
+* Rails: 5.x, 6.x, and 7.x.
 * Works outside of Rails with the `json` (for MRI) or `json_pure` (for JRuby) gem.
 
 
@@ -78,7 +78,7 @@ results.first.address
 # => "Hôtel de Ville, 75004 Paris, France"
 ```
 
-You can also look up the location of an IP addresses:
+You can also look up the location of an IP address:
 
 ```ruby
 results = Geocoder.search("172.56.21.89")
@@ -350,10 +350,16 @@ This example uses Redis, but the cache store can be any object that supports the
 
 Even a plain Ruby hash will work, though it's not a great choice (cleared out when app is restarted, not shared between app instances, etc).
 
+When using Rails use the Generic cache store as an adapter around `Rails.cache`:
+
+```ruby
+Geocoder.configure(cache: Geocoder::CacheStore::Generic.new(Rails.cache, {}))
+```
+
 You can also set a custom prefix to be used for cache keys:
 
 ```ruby
-Geocoder.configure(cache_prefix: "...")
+Geocoder.configure(cache_options: { prefix: "..." })
 ```
 
 By default the prefix is `geocoder:`

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/geocoder/configuration.rb

@@ -108,8 +108,8 @@ 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:" # - DEPRECATED - prefix (string) to use for all cache keys
+      @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[: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
@@ -124,7 +124,8 @@ module Geocoder
       @data[:distances] = :linear  # :linear or :spherical
 
       # explicit cache service options
-      @data[:cache_options] = {}
+      @data[:cache_options] ||= {}
+      @data[:cache_options][:prefix] = "geocoder:"
     end
 
     instance_eval(OPTIONS.map do |option|

data/lib/geocoder/lookup.rb

@@ -117,8 +117,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 " +
@@ -132,5 +131,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 = "Geocoder::Lookup::#{classify_name(name)}"
+      begin
+        Geocoder::Lookup.const_get(class_name)
+      rescue NameError
+        require "geocoder/lookups/#{name}"
+      end
+      Geocoder::Lookup.const_get(class_name).new
+    end
   end
 end

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

@@ -11,6 +11,10 @@ module Geocoder::Lookup
       ["api_key"]
     end
 
+    def supported_protocols
+      [:https]
+    end
+
     private # ----------------------------------------------------------------
 
     def base_query_url(query)
@@ -25,7 +29,7 @@ module Geocoder::Lookup
     end
 
     def configured_host
-      configuration[:host] || "locationiq.org"
+      configuration[:host] || "us1.locationiq.com"
     end
 
     def results(query)

data/lib/geocoder/results/nominatim.rb

@@ -4,12 +4,12 @@ module Geocoder::Result
   class Nominatim < Base
 
     def poi
-      return @data['address'][place_type] if @data['address'].key?(place_type)
+      return address_data[place_type] if address_data.key?(place_type)
       return nil
     end
 
     def house_number
-      @data['address']['house_number']
+      address_data['house_number']
     end
 
     def address
@@ -18,69 +18,71 @@ module Geocoder::Result
 
     def street
       %w[road pedestrian highway].each do |key|
-        return @data['address'][key] if @data['address'].key?(key)
+        return address_data[key] if address_data.key?(key)
       end
       return nil
     end
 
     def city
       %w[city town village hamlet].each do |key|
-        return @data['address'][key] if @data['address'].key?(key)
+        return address_data[key] if address_data.key?(key)
       end
       return nil
     end
 
     def village
-      @data['address']['village']
+      address_data['village']
     end
 
     def town
-      @data['address']['town']
+      address_data['town']
     end
 
     def state
-      @data['address']['state']
+      address_data['state']
     end
 
     alias_method :state_code, :state
 
     def postal_code
-      @data['address']['postcode']
+      address_data['postcode']
     end
 
     def county
-      @data['address']['county']
+      address_data['county']
     end
 
     def country
-      @data['address']['country']
+      address_data['country']
     end
 
     def country_code
-      @data['address']['country_code']
+      address_data['country_code']
     end
 
     def suburb
-      @data['address']['suburb']
+      address_data['suburb']
     end
 
     def city_district
-      @data['address']['city_district']
+      address_data['city_district']
     end
 
     def state_district
-      @data['address']['state_district']
+      address_data['state_district']
     end
 
     def neighbourhood
-      @data['address']['neighbourhood']
+      address_data['neighbourhood']
     end
 
     def municipality
-      @data['address']['municipality']
+      address_data['municipality']
     end
 
     def coordinates
+      return [] unless @data['lat'] && @data['lon']
+
       [@data['lat'].to_f, @data['lon'].to_f]
     end
 
@@ -109,5 +111,11 @@ module Geocoder::Result
         end
       end
     end
+
+    private
+
+    def address_data
+      @data['address'] || {}
+    end
   end
 end

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.7.2"
+  VERSION = "1.7.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geocoder
 version: !ruby/object:Gem::Version
-  version: 1.7.2
+  version: 1.7.5
 platform: ruby
 authors:
 - Alex Reisner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-02 00:00:00.000000000 Z
+date: 2022-03-14 00:00:00.000000000 Z
 dependencies: []
 description: Object geocoding (by street or IP address), reverse geocoding (coordinates
   to street address), distance queries for ActiveRecord and Mongoid, result caching,
@@ -25,8 +25,7 @@ files:
 - README.md
 - bin/console
 - bin/geocode
-- examples/autoexpire_cache_dalli.rb
-- examples/autoexpire_cache_redis.rb
+- examples/app_defined_lookup_services.rb
 - examples/cache_bypass.rb
 - examples/reverse_geocode_job.rb
 - lib/easting_northing.rb

data/examples/autoexpire_cache_dalli.rb

@@ -1,62 +0,0 @@
-# This class implements a cache with simple delegation to the the Dalli Memcached client
-# https://github.com/mperham/dalli
-#
-# A TTL is set on initialization
-
-class AutoexpireCacheDalli
-  def initialize(store, ttl = 86400)
-    @store = store
-    @keys = 'GeocoderDalliClientKeys'
-    @ttl = ttl
-  end
-
-  def [](url)
-    res = @store.get(url)
-    res = YAML::load(res) if res.present?
-    res
-  end
-
-  def []=(url, value)
-    if value.nil?
-      del(url)
-    else
-      key_cache_add(url) if @store.add(url, YAML::dump(value), @ttl)
-    end
-    value
-  end
-
-  def keys
-    key_cache
-  end
-
-  def del(url)
-    key_cache_delete(url) if @store.delete(url)
-  end
-
-  private
-
-  def key_cache
-    the_keys = @store.get(@keys)
-    if the_keys.nil?
-      @store.add(@keys, YAML::dump([]))
-      []
-    else
-      YAML::load(the_keys)
-    end
-  end
-
-  def key_cache_add(key)
-    @store.replace(@keys, YAML::dump(key_cache << key))
-  end
-
-  def key_cache_delete(key)
-    tmp = key_cache
-    tmp.delete(key)
-    @store.replace(@keys, YAML::dump(tmp))
-  end
-end
-
-# Here Dalli is set up as on Heroku using the Memcachier gem.
-# https://devcenter.heroku.com/articles/memcachier#ruby
-# On other setups you might have to specify your Memcached server in Dalli::Client.new
-Geocoder.configure(:cache => AutoexpireCacheDalli.new(Dalli::Client.new))

data/examples/autoexpire_cache_redis.rb

@@ -1,30 +0,0 @@
-# This class implements a cache with simple delegation to the Redis store, but
-# when it creates a key/value pair, it also sends an EXPIRE command with a TTL.
-# It should be fairly simple to do the same thing with Memcached.
-# Alternatively, this class could inherit from Redis, which would make most
-# of the below methods unnecessary.
-class AutoexpireCacheRedis
-  def initialize(store, ttl = 86400)
-    @store = store
-    @ttl = ttl
-  end
-
-  def [](url)
-    @store.get(url)
-  end
-
-  def []=(url, value)
-    @store.set(url, value)
-    @store.expire(url, @ttl)
-  end
-
-  def keys
-    @store.keys
-  end
-
-  def del(url)
-    @store.del(url)
-  end
-end
-
-Geocoder.configure(:cache => AutoexpireCacheRedis.new(Redis.new))