geocoder 1.4.4 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d93c7deeb30de425af22733c64e2a6297f610a4
-  data.tar.gz: 46c3d2b77ddb91bee2156bebebf102b73c1fd328
+  metadata.gz: aafaf6b62b506a191b17fcdde0bb1b325769fc8a
+  data.tar.gz: 61f40f9ac0c89f3bcf25ff417515b60b2421f14c
 SHA512:
-  metadata.gz: 327e8d5c40c31aa09be5b8e9d0b55ec18e74a8da166d0d65882fe31760182c4d96b36bfe3c0261cdeb2a5b91aefca204114d7bcc54dd46ea68e1cb7f0b7e3fd0
-  data.tar.gz: 5ad20ece66d7117b6e0928dd19daf8f602496a9b033fcf6833f58a0f6d9efd87388289681adf3a96a7c4ad71e159d7b06c956aca2e3646cdf8087bd4a570aec7
+  metadata.gz: 0ee51c45355b969282a51fd79725e5fae1538dc56a5b60e659c0b2d3e072c72e83886f9d0d145928e977ed457d4753f5e0cbd424c0fe5c673d1f741a11a200d2
+  data.tar.gz: 6e4816464c910b0be21bc75d78c2290aabb44b1563af5bac86e6db48b6bae83a5b62c80b8c88c21240b0f8d45c75079e79557698e3aa8ebca4dccfbd99208eb3

data/CHANGELOG.md

@@ -3,6 +3,15 @@ Changelog
 
 Major changes to Geocoder for each release. Please see the Git log for complete list of changes.
 
+1.4.5 (2017 Nov 29)
+-------------------
+* Add support for :pickpoint lookup (thanks github.com/cylon-v).
+* Add support for :db_ip_com lookup (thanks github.com/cv).
+* Change FreeGeoIP host to freegeoip.net.
+* Allow search radius to be a symbol representing a column in DB (thanks github.com/leonelgalan).
+* Add support for new parameters and improved error handling for several lookups.
+* Fix bug in SQL when searching for objects across 180th meridian.
+
 1.4.4 (2017 May 17)
 -------------------
 * Use HTTPS by default for :freegeoip (thanks github.com/mehanoid).

data/README.md

@@ -114,6 +114,10 @@ Geocoder will print warnings if you exceed the rate limit for your geocoding ser
 
     rake geocode:all CLASS=YourModel SLEEP=0.25 BATCH=100
 
+To avoid per-day limit issues (for example if you are trying to geocode thousands of objects and don't want to reach the limit), you can add a `LIMIT` option. Warning: This will ignore the `BATCH` value if provided.
+
+    rake geocode:all CLASS=YourModel LIMIT=1000
+
 ### Avoiding Unnecessary API Requests
 
 Geocoding only needs to be performed under certain conditions. To avoid unnecessary work (and quota usage) you will probably want to geocode an object only when:
@@ -176,11 +180,11 @@ Some utility methods are also available:
     # look up coordinates of some location (like searching Google Maps)
     Geocoder.coordinates("25 Main St, Cooperstown, NY")
      => [42.700149, -74.922767]
-    
+
     # distance between Eiffel Tower and Empire State Building
     Geocoder::Calculations.distance_between([47.858205,2.294359], [40.748433,-73.985655])
      => 3619.77359999382 # in configured units (default miles)
-    
+
     # find the geographic center (aka center of gravity) of objects or points
     Geocoder::Calculations.geographic_center([city1, city2, [40.22,-73.99], city4])
      => [35.14968, -90.048929]
@@ -333,29 +337,29 @@ Some common configuration options are:
 
     # config/initializers/geocoder.rb
     Geocoder.configure(
-    
+
       # geocoding service (see below for supported options):
       :lookup => :yandex,
-    
+
       # IP address geocoding service (see below for supported options):
       :ip_lookup => :maxmind,
-    
+
       # to use an API key:
       :api_key => "...",
-    
+
       # geocoding service request timeout, in seconds (default 3):
       :timeout => 5,
-    
+
       # set default units to kilometers:
       :units => :km,
-    
+
       # caching (see below for details):
       :cache => Redis.new,
       :cache_prefix => "..."
-    
+
     )
 
-Please see `lib/geocoder/configuration.rb` for a complete list of configuration options. Additionally, some lookups have their own configuration options, some of which are directly supported by Geocoder. For example, to specify a value for Google's `bounds` parameter:
+Please see [`lib/geocoder/configuration.rb`](https://github.com/alexreisner/geocoder/blob/master/lib/geocoder/configuration.rb) for a complete list of configuration options. Additionally, some lookups have their own configuration options, some of which are directly supported by Geocoder. For example, to specify a value for Google's `bounds` parameter:
 
     # with Google:
     Geocoder.search("Paris", :bounds => [[32.1,-95.9], [33.9,-94.3]])
@@ -369,27 +373,41 @@ Or, to search within a particular region with Google:
 
     Geocoder.search("...", :params => {:region => "..."})
 
-You can also configure multiple geocoding services at once, like this:
+Or, to use parameters in your model:
+
+    class Venue
+
+      # build an address from street, city, and state attributes
+      geocoded_by :address_from_components, :params => {:region => "..."}
+
+      # store the fetched address in the full_address attribute
+      reverse_geocoded_by :latitude, :longitude, :address => :full_address, :params => {:region => "..."}
+    end
+
+
+### Configure Multiple Services
+
+You can configure multiple geocoding services at once, like this:
 
     Geocoder.configure(
 
       :timeout => 2,
       :cache => Redis.new,
-    
+
       :yandex => {
         :api_key => "...",
         :timeout => 5
       },
-    
+
       :baidu => {
         :api_key => "..."
       },
-    
+
       :maxmind => {
         :api_key => "...",
         :service => :omni
       }
-    
+
     )
 
 The above combines global and service-specific options and could be useful if you specify different geocoding services for different models or under different conditions. Lookup-specific settings override global settings. In the above example, the timeout for all lookups would be 2 seconds, except for Yandex which would be 5.
@@ -407,7 +425,9 @@ The following is a comparison of the supported geocoding APIs. The "Limitations"
 * **Region**: world
 * **SSL support**: yes (required if key is used)
 * **Languages**: see https://developers.google.com/maps/faq#languagesupport
-* **Extra options**: `:bounds` - pass SW and NE coordinates as an array of two arrays to bias results towards a viewport
+* **Extra params**:
+  * `:bounds` - pass SW and NE coordinates as an array of two arrays to bias results towards a viewport
+  * `:google_place_id` - pass `true` if search query is a Google Place ID
 * **Documentation**: https://developers.google.com/maps/documentation/geocoding/intro
 * **Terms of Service**: http://code.google.com/apis/maps/terms.html#section_10_12
 * **Limitations**: "You must not use or display the Content without a corresponding Google map, unless you are explicitly permitted to do so in the Maps APIs Documentation, or through written permission from Google." "You must not pre-fetch, cache, or store any Content, except that you may store: (i) limited amounts of Content for the purpose of improving the performance of your Maps API Implementation..."
@@ -463,22 +483,34 @@ The [Google Places Search API](https://developers.google.com/places/web-service/
 * **Terms of Service**: http://wiki.openstreetmap.org/wiki/Nominatim_usage_policy
 * **Limitations**: Please limit request rate to 1 per second and include your contact information in User-Agent headers (eg: `Geocoder.configure(:http_headers => { "User-Agent" => "your contact info" })`). [Data licensed under Open Database License (ODbL) (you must provide attribution).](http://www.openstreetmap.org/copyright)
 
+#### PickPoint (`:pickpoint`)
+
+* **API key**: required
+* **Key signup**: [https://pickpoint.io](https://pickpoint.io)
+* **Quota**: 2500 requests / day for free non-commercial usage, commercial plans are [available](https://pickpoint.io/#pricing). No rate limit.
+* **Region**: world
+* **SSL support**: required
+* **Languages**: worldwide
+* **Documentation**: [https://pickpoint.io/api-reference](https://pickpoint.io/api-reference)
+* **Limitations**: [Data licensed under Open Database License (ODbL) (you must provide attribution).](http://www.openstreetmap.org/copyright)
+
+
 #### LocationIQ (`:location_iq`)
 
 * **API key**: required
-* **Quota**: 6 request/second (30k req/day), then ability to purchase more
+* **Quota**: 60 requests/minute (2 req/sec, 10k req/day), then [ability to purchase more](http://locationiq.org/#pricing)
 * **Region**: world
 * **SSL support**: yes
 * **Languages**: ?
-* **Documentation**: http://locationiq.org/#docs
+* **Documentation**: https://locationiq.org/#docs
 * **Terms of Service**: https://unwiredlabs.com/tos
-* **Limitations**: [Data licensed under Open Database License (ODbL) (you must provide attribution).](http://www.openstreetmap.org/copyright)
+* **Limitations**: [Data licensed under Open Database License (ODbL) (you must provide attribution).](https://www.openstreetmap.org/copyright)
 
 #### OpenCageData (`:opencagedata`)
 
 * **API key**: required
 * **Key signup**: http://geocoder.opencagedata.com
-* **Quota**: 2500 requests / day, then ability to purchase more (free during beta)
+* **Quota**: 2500 requests / day, then [ability to purchase more](https://geocoder.opencagedata.com/pricing)
 * **Region**: world
 * **SSL support**: yes
 * **Languages**: worldwide
@@ -507,18 +539,6 @@ The [Google Places Search API](https://developers.google.com/places/web-service/
 * **Terms of Service**: http://geocoder.ca/?terms=1
 * **Limitations**: "Under no circumstances can our data be re-distributed or re-sold by anyone to other parties without our written permission."
 
-#### Geocoder.us (`:geocoder_us`)
-
-* **API key**: HTTP Basic Auth
-* **Sign up**: http://geocoder.us/user/signup
-* **Quota**: You can purchase 20,000 credits at a time for $50
-* **Region**: US
-* **SSL support**: no
-* **Languages**: English
-* **Documentation**: http://geocoder.us/help/
-* **Terms of Service**: http://geocoder.us/terms.shtml
-* **Limitations**: ?
-
 #### Mapbox (`:mapbox`)
 
 * **API key**: required
@@ -528,6 +548,12 @@ The [Google Places Search API](https://developers.google.com/places/web-service/
 * **Region**: complete coverage of US and Canada, partial coverage elsewhere (see for details: https://www.mapbox.com/developers/api/geocoding/#coverage)
 * **SSL support**: yes
 * **Languages**: English
+* **Extra params** (see Mapbox docs for more):
+    * `:country` - restrict results to a specific country, e.g., `us` or `ca`
+    * `:types` - restrict results to categories such as `address`,
+    `neighborhood`, `postcode`
+    * `:proximity` - bias results toward a `lng,lat`, e.g.,
+        `params: { proximity: "-84.0,42.5" }`
 * **Documentation**: https://www.mapbox.com/developers/api/geocoding/
 * **Terms of Service**: https://www.mapbox.com/tos/
 * **Limitations**: For `mapbox.places` dataset, must be displayed on a Mapbox map; Cache results for up to 30 days. For `mapbox.places-permanent` dataset, depends on plan.
@@ -585,24 +611,24 @@ The [Google Places Search API](https://developers.google.com/places/web-service/
 #### Mapzen (`:mapzen`)
 
 * **API key**: required
-* **Quota**: 6/sec, up to 30k per day, paid plan info at https://mapzen.com/documentation/search/api-keys-rate-limits/#rate-limits
+* **Quota**: 25,000 free requests/month and [ability to purchase more](https://mapzen.com/pricing/)
 * **Region**: world
 * **SSL support**: yes
-* **Languages**: en
+* **Languages**: en; see https://mapzen.com/documentation/search/language-codes/
 * **Documentation**: https://mapzen.com/documentation/search/search/
 * **Terms of Service**: http://mapzen.com/terms
-* **Limitations**: ?
+* **Limitations**: [You must provide attribution](https://mapzen.com/rights/)
 * **Notes**: Mapzen is the primary author of Pelias and offers Pelias-as-a-service in free and paid versions https://mapzen.com/pelias.
 
 #### Pelias (`:pelias`)
 
-* **API key**: required
+* **API key**: configurable (self-hosted service)
 * **Quota**: none (self-hosted service)
 * **Region**: world
 * **SSL support**: yes
-* **Languages**: en
-* **Documentation**: https://mapzen.com/documentation/search/search/
-* **Terms of Service**: http://mapzen.com/terms
+* **Languages**: en; see https://mapzen.com/documentation/search/language-codes/
+* **Documentation**: http://pelias.io/
+* **Terms of Service**: http://pelias.io/data_licenses.html
 * **Limitations**: See terms
 * **Notes**: Configure your self-hosted pelias with the `endpoint` option: `Geocoder.configure(:lookup => :pelias, :api_key => 'your_api_key', :pelias => {:endpoint => 'self.hosted/pelias'})`. Defaults to `localhost`.
 
@@ -611,7 +637,7 @@ The [Google Places Search API](https://developers.google.com/places/web-service/
 Data Science Toolkit provides an API whose response format is like Google's but which can be set up as a privately hosted service.
 
 * **API key**: none
-* **Quota**: None quota if you are self-hosting the service.
+* **Quota**: No quota if you are self-hosting the service.
 * **Region**: world
 * **SSL support**: ?
 * **Languages**: en
@@ -635,7 +661,7 @@ Data Science Toolkit provides an API whose response format is like Google's but
 #### Geocodio (`:geocodio`)
 
 * **API key**: required
-* **Quota**: 2,500 free requests/day then purchase $.001 for each, also has volume pricing and plans
+* **Quota**: 2,500 free requests/day then purchase $0.0005 for each, also has volume pricing and plans.
 * **Region**: US
 * **SSL support**: yes
 * **Languages**: en
@@ -646,7 +672,7 @@ Data Science Toolkit provides an API whose response format is like Google's but
 #### SmartyStreets (`:smarty_streets`)
 
 * **API key**: requires auth_id and auth_token (set `Geocoder.configure(:api_key => [id, token])`)
-* **Quota**: 10,000 free, 250/month then purchase at sliding scale.
+* **Quota**: 250/month then purchase at sliding scale.
 * **Region**: US
 * **SSL support**: yes (required)
 * **Languages**: en
@@ -730,7 +756,7 @@ This uses the PostcodeAnywhere UK Geocode service, this will geocode any string
 #### FreeGeoIP (`:freegeoip`)
 
 * **API key**: none
-* **Quota**: 10000 requests per hour. After reaching the hourly quota, all of your requests will result in HTTP 403 (Forbidden) until it clears up on the next roll over.
+* **Quota**: 15,000 requests per hour. After reaching the hourly quota, all of your requests will result in HTTP 403 (Forbidden) until it clears up on the next roll over.
 * **Region**: world
 * **SSL support**: no
 * **Languages**: English
@@ -761,7 +787,8 @@ This uses the PostcodeAnywhere UK Geocode service, this will geocode any string
 * **Documentation**: https://market.mashape.com/fcambus/telize
 * **Terms of Service**: ?
 * **Limitations**: ?
-* **Notes**: To use Telize set `Geocoder.configure(:ip_lookup => :telize, :api_key => "your_api_key")`.
+* **Notes**: To use Telize set `Geocoder.configure(:ip_lookup => :telize, :api_key => "your_api_key")`. Or configure your self-hosted telize with the `host` option: `Geocoder.configure(:ip_lookup => :telize, :telize => {:host => "localhost"})`.
+
 
 #### MaxMind Legacy Web Services (`:maxmind`)
 
@@ -819,6 +846,16 @@ This uses the PostcodeAnywhere UK Geocode service, this will geocode any string
 * **Documentation**: http://ip-api.com/docs/
 * **Terms of Service**: https://signup.ip-api.com/terms
 
+#### DB-IP.com (`:db_ip_com`)
+
+* **API key**: required
+* **Quota**: 2,500/day (with free API Key, 50,000/day and up for paid API keys)
+* **Region**: world
+* **SSL support**: yes (with paid API keys - see https://db-ip.com/api/)
+* **Languages**: English (English with free API key, multiple languages with paid API keys)
+* **Documentation**: https://db-ip.com/api/doc.php
+* **Terms of Service**: https://db-ip.com/tos.php
+
 ### IP Address Local Database Services
 
 #### MaxMind Local (`:maxmind_local`) - EXPERIMENTAL
@@ -847,7 +884,7 @@ You can generate ActiveRecord migrations and download and import data via provid
 
     # generate migration to create tables
     rails generate geocoder:maxmind:geolite_city
-    
+
     # download, unpack, and import data
     rake geocoder:maxmind:geolite:load PACKAGE=city
 
@@ -936,7 +973,7 @@ For example:
 
       # build an address from street, city, and state attributes
       geocoded_by :address_from_components
-    
+
       # store the fetched address in the full_address attribute
       reverse_geocoded_by :latitude, :longitude, :address => :full_address
     end
@@ -948,7 +985,7 @@ However, there can be only one set of latitude/longitude attributes, and whichev
       geocoded_by :address,
         :latitude  => :fetched_latitude,  # this will be overridden by the below
         :longitude => :fetched_longitude  # same here
-    
+
       reverse_geocoded_by :latitude, :longitude
     end
 
@@ -976,7 +1013,7 @@ For example:
 
       after_validation :reverse_geocode, :if => :has_coordinates
       after_validation :geocode, :if => :has_location, :unless => :has_coordinates
-    
+
     end
 
 Use Outside of Rails
@@ -999,8 +1036,7 @@ When writing tests for an app that uses Geocoder it may be useful to avoid netwo
     Geocoder::Lookup::Test.add_stub(
       "New York, NY", [
         {
-          'latitude'     => 40.7143528,
-          'longitude'    => -74.0059731,
+          'coordinates'  => [40.7143528, -74.0059731],
           'address'      => 'New York, NY, USA',
           'state'        => 'New York',
           'state_code'   => 'NY',
@@ -1010,15 +1046,14 @@ When writing tests for an app that uses Geocoder it may be useful to avoid netwo
       ]
     )
 
-Now, any time Geocoder looks up "New York, NY" its results array will contain one result with the above attributes. You can also set a default stub, to be returned when no other stub is found for a given query:
+Now, any time Geocoder looks up "New York, NY" its results array will contain one result with the above attributes. Note each lookup requires an exact match to the text you provide as the first argument. The above example would, therefore, not match a request for "New York, NY, USA" and a second stub would need to be created to match that particular request. You can also set a default stub, to be returned when no other stub is found for a given query:
 
     Geocoder.configure(:lookup => :test)
 
     Geocoder::Lookup::Test.set_default_stub(
       [
         {
-          'latitude'     => 40.7143528,
-          'longitude'    => -74.0059731,
+          'coordinates'  => [40.7143528, -74.0059731],
           'address'      => 'New York, NY, USA',
           'state'        => 'New York',
           'state_code'   => 'NY',
@@ -1197,7 +1232,9 @@ When reporting an issue, please list the version of Geocoder you are using and a
 Please DO NOT use GitHub issues to ask questions about how to use Geocoder. Sites like [StackOverflow](http://www.stackoverflow.com/) are a better forum for such discussions.
 
 
-### Known Issue
+### Known Issues
+
+#### Using `near` with `includes`
 
 You cannot use the `near` scope with another scope that provides an `includes` option because the `SELECT` clause generated by `near` will overwrite it (or vice versa).
 
@@ -1206,7 +1243,7 @@ Instead of using `includes` to reduce the number of database queries, try using
     # Pass a :select option to the near scope to get the columns you want.
     # Instead of City.near(...).includes(:venues), try:
     City.near("Omaha, NE", 20, :select => "cities.*, venues.*").joins(:venues)
-    
+
     # This preload call will normally trigger two queries regardless of the
     # number of results; one query on hotels, and one query on administrators.
     # Instead of Hotel.near(...).includes(:administrator), try:
@@ -1214,6 +1251,10 @@ Instead of using `includes` to reduce the number of database queries, try using
 
 If anyone has a more elegant solution to this problem I am very interested in seeing it.
 
+#### Using `near` with objects close to the 180th meridian
+
+The `near` method will not look across the 180th meridian to find objects close to a given point. In practice this is rarely an issue outside of New Zealand and certain surrounding islands. This problem does not exist with the zero-meridian. The problem is due to a shortcoming of the Haversine formula which Geocoder uses to calculate distances.
+
 
 Contributing
 ------------

data/lib/generators/geocoder/maxmind/geolite_city_generator.rb

@@ -1,10 +1,12 @@
 require 'rails/generators/migration'
+require 'generators/geocoder/migration_version'
 
 module Geocoder
   module Generators
     module Maxmind
       class GeoliteCityGenerator < Rails::Generators::Base
         include Rails::Generators::Migration
+        include Generators::MigrationVersion
 
         source_root File.expand_path('../templates', __FILE__)
 

data/lib/generators/geocoder/maxmind/geolite_country_generator.rb

@@ -1,10 +1,12 @@
 require 'rails/generators/migration'
+require 'generators/geocoder/migration_version'
 
 module Geocoder
   module Generators
     module Maxmind
       class GeoliteCountryGenerator < Rails::Generators::Base
         include Rails::Generators::Migration
+        include Generators::MigrationVersion
 
         source_root File.expand_path('../templates', __FILE__)
 

data/lib/generators/geocoder/maxmind/templates/migration/geolite_city.rb

@@ -1,4 +1,4 @@
-class GeocoderMaxmindGeoliteCity < ActiveRecord::Migration
+class GeocoderMaxmindGeoliteCity < ActiveRecord::Migration<%= migration_version %>
   def self.up
     create_table :maxmind_geolite_city_blocks, id: false do |t|
       t.column :start_ip_num, :bigint, null: false

data/lib/generators/geocoder/maxmind/templates/migration/geolite_country.rb

@@ -1,4 +1,4 @@
-class GeocoderMaxmindGeoliteCountry < ActiveRecord::Migration
+class GeocoderMaxmindGeoliteCountry < ActiveRecord::Migration<%= migration_version %>
   def self.up
     create_table :maxmind_geolite_country, id: false do |t|
       t.column :start_ip, :string

data/lib/generators/geocoder/migration_version.rb

@@ -0,0 +1,15 @@
+module Geocoder
+  module Generators
+    module MigrationVersion
+      def rails_5?
+        Rails::VERSION::MAJOR == 5
+      end
+
+      def migration_version
+        if rails_5?
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/lookup.rb

@@ -41,6 +41,7 @@ module Geocoder
         :opencagedata,
         :ovi,
         :pelias,
+        :pickpoint,
         :here,
         :baidu,
         :geocodio,
@@ -69,7 +70,8 @@ module Geocoder
         :pointpin,
         :maxmind_geoip2,
         :ipinfo_io,
-        :ipapi_com
+        :ipapi_com,
+        :db_ip_com
       ]
     end
 

data/lib/geocoder/lookups/base.rb

@@ -286,7 +286,7 @@ module Geocoder
         end
       rescue Timeout::Error
         raise Geocoder::LookupTimeout
-      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ENETUNREACH
+      rescue Errno::EHOSTUNREACH, Errno::ETIMEDOUT, Errno::ENETUNREACH, Errno::ECONNRESET
         raise Geocoder::NetworkError
       end
 

data/lib/geocoder/lookups/db_ip_com.rb

@@ -0,0 +1,49 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/db_ip_com'
+
+module Geocoder::Lookup
+  class DbIpCom < Base
+
+    def name
+      'DB-IP.com'
+    end
+
+    def supported_protocols
+      [:https, :http]
+    end
+
+    def required_api_key_parts
+      ['api_key']
+    end
+
+    def query_url(query)
+      query_params = if query.options[:params]
+        "?#{url_query_string(query)}"
+      end
+
+      "#{protocol}://api.db-ip.com/v2/#{configuration.api_key}/#{query.sanitized_text}#{query_params}"
+    end
+
+    private
+
+    def results(query)
+      return [] unless (doc = fetch_data(query))
+
+      case doc['error']
+      when 'maximum number of queries per day exceeded'
+        raise_error Geocoder::OverQueryLimitError ||
+                    Geocoder.log(:warn, 'DB-API query limit exceeded.')
+
+      when 'invalid API key'
+        raise_error Geocoder::InvalidApiKey ||
+                    Geocoder.log(:warn, 'Invalid DB-IP API key.')
+      when nil
+        [doc]
+
+      else
+        raise_error Geocoder::Error ||
+                    Geocoder.log(:warn, "Request failed: #{doc['error']}")
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/freegeoip.rb

@@ -50,7 +50,7 @@ module Geocoder::Lookup
     end
 
     def host
-      configuration[:host] || "freegeoip.io"
+      configuration[:host] || "freegeoip.net"
     end
   end
 end

data/lib/geocoder/lookups/google.rb

@@ -63,10 +63,14 @@ module Geocoder::Lookup
 
     def query_url_google_params(query)
       params = {
-        (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
         :sensor => "false",
         :language => (query.language || configuration.language)
       }
+      if query.options[:google_place_id]
+        params[:place_id] = query.sanitized_text
+      else
+        params[(query.reverse_geocode? ? :latlng : :address)] = query.sanitized_text
+      end
       unless (bounds = query.options[:bounds]).nil?
         params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join('|')
       end

data/lib/geocoder/lookups/location_iq.rb

@@ -12,9 +12,8 @@ module Geocoder::Lookup
     end
     
     def query_url(query)
-      method = query.reverse_geocode? ? "reverse.php" : "search.php"
-      host = configuration[:host] || "locationiq.org/v1"
-      "#{protocol}://#{host}/#{method}?key=#{configuration.api_key}&" + url_query_string(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      "#{protocol}://locationiq.org/v1/#{method}.php?key=#{configuration.api_key}&" + url_query_string(query)
     end
 
     private
@@ -22,8 +21,17 @@ module Geocoder::Lookup
     def results(query)
       return [] unless doc = fetch_data(query)
 
-      if !doc.is_a?(Array) && doc['error'] =~ /Invalid\skey/
-        raise_error(Geocoder::InvalidApiKey, doc['error'])
+      if !doc.is_a?(Array)
+        case doc['error']
+        when "Invalid key"
+          raise_error(Geocoder::InvalidApiKey, doc['error'])
+        when "Key not active - Please write to contact@unwiredlabs.com"
+          raise_error(Geocoder::RequestDenied, doc['error'])
+        when "Rate Limited"
+          raise_error(Geocoder::OverQueryLimitError, doc['error'])
+        when "Unknown error - Please try again after some time"
+          raise_error(Geocoder::InvalidRequest, doc['error'])
+        end
       end
 
       doc.is_a?(Array) ? doc : [doc]

data/lib/geocoder/lookups/mapbox.rb

@@ -9,7 +9,8 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{url_query_string(query)}.json?access_token=#{configuration.api_key}"
+      path = "#{mapbox_search_term(query)}.json?#{url_query_string(query)}"
+      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{path}"
     end
 
     private # ---------------------------------------------------------------
@@ -25,7 +26,11 @@ module Geocoder::Lookup
       end
     end
 
-    def url_query_string(query)
+    def query_url_params(query)
+      {access_token: configuration.api_key}.merge(super(query))
+    end
+
+    def mapbox_search_term(query)
       require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
       if query.reverse_geocode?
         lat,lon = query.coordinates

data/lib/geocoder/lookups/opencagedata.rb

@@ -47,7 +47,7 @@ module Geocoder::Lookup
         :language => (query.language || configuration.language)
       }.merge(super)
 
-      [:countrycode, :min_confidence, :no_dedupe, :no_annotations, :no_record, :limit].each do |option|
+      [:abbrv, :countrycode, :min_confidence, :no_dedupe, :no_annotations, :no_record, :limit].each do |option|
         unless (option_value = query.options[option]).nil?
           params[option] = option_value
         end

data/lib/geocoder/lookups/pickpoint.rb

@@ -0,0 +1,35 @@
+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
+
+    def query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "forward"
+      "#{protocol}://api.pickpoint.io/v1/#{method}?key=#{configuration.api_key}&" + url_query_string(query)
+    end
+
+    private
+
+    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/yandex.rb

@@ -47,12 +47,16 @@ module Geocoder::Lookup
       else
         q = query.sanitized_text
       end
-      {
+      params = {
         :geocode => q,
         :format => "json",
         :plng => "#{query.language || configuration.language}", # supports ru, uk, be
         :key => configuration.api_key
-      }.merge(super)
+      }
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bbox] = bounds.map{ |point| "%f,%f" % point }.join('~')
+      end
+      params.merge(super)
     end
   end
 end

data/lib/geocoder/models/active_record.rb

@@ -18,7 +18,8 @@ module Geocoder
           :units         => options[:units],
           :method        => options[:method],
           :lookup        => options[:lookup],
-          :language      => options[:language]
+          :language      => options[:language],
+          :params        => options[:params]
         )
       end
 
@@ -35,7 +36,8 @@ module Geocoder
           :units           => options[:units],
           :method          => options[:method],
           :lookup          => options[:lookup],
-          :language        => options[:language]
+          :language        => options[:language],
+          :params          => options[:params]
         )
       end
 
@@ -47,4 +49,3 @@ module Geocoder
     end
   end
 end
-

data/lib/geocoder/results/db_ip_com.rb

@@ -0,0 +1,63 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class DbIpCom < Base
+
+    def coordinates
+      ['latitude', 'longitude'].map{ |coordinate_name| @data[coordinate_name] }
+    end
+
+    def address(format = :full)
+      s = state_code.to_s == "" ? "" : ", #{state_code}"
+      "#{city}#{s} #{zip_code}, #{country_name}".sub(/^[ ,]*/, "")
+    end
+
+    def city
+      @data['city']
+    end
+
+    def district
+      @data['district']
+    end
+
+    def state_code
+      @data['stateProv']
+    end
+    alias_method :state, :state_code
+
+    def zip_code
+      @data['zipCode']
+    end
+    alias_method :postal_code, :zip_code
+
+    def country_name
+      @data['countryName']
+    end
+    alias_method :country, :country_name
+
+    def country_code
+      @data['countryCode']
+    end
+
+    def continent_name
+      @data['continentName']
+    end
+    alias_method :continent, :continent_name
+
+    def continent_code
+      @data['continentCode']
+    end
+
+    def time_zone
+      @data['timeZone']
+    end
+
+    def gmt_offset
+      @data['gmtOffset']
+    end
+
+    def currency_code
+      @data['currencyCode']
+    end
+  end
+end

data/lib/geocoder/results/nominatim.rb

@@ -64,6 +64,18 @@ module Geocoder::Result
       @data['address']['suburb']
     end
 
+    def city_district
+      @data['address']['city_district']
+    end
+
+    def state_district
+      @data['address']['state_district']
+    end
+
+    def neighbourhood
+      @data['address']['neighbourhood']
+    end
+
     def coordinates
       [@data['lat'].to_f, @data['lon'].to_f]
     end

data/lib/geocoder/results/opencagedata.rb

@@ -75,6 +75,15 @@ module Geocoder::Result
       [south, west, north, east]
     end
 
+    def time_zone
+      # The OpenCage API documentation states that `annotations` is available
+      # "when possible" https://geocoder.opencagedata.com/api#annotations
+      @data
+        .fetch('annotations', {})
+        .fetch('timezone', {})
+        .fetch('name', nil)
+    end
+
     def self.response_attributes
       %w[boundingbox license 
         formatted stadium]

data/lib/geocoder/results/pickpoint.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/nominatim'
+
+module Geocoder::Result
+  class Pickpoint < Nominatim
+  end
+end

data/lib/geocoder/sql.rb

@@ -47,8 +47,8 @@ module Geocoder
       spans = "#{lat_attr} BETWEEN #{sw_lat} AND #{ne_lat} AND "
       # handle box that spans 180 longitude
       if sw_lng.to_f > ne_lng.to_f
-        spans + "#{lon_attr} BETWEEN #{sw_lng} AND 180 OR " +
-        "#{lon_attr} BETWEEN -180 AND #{ne_lng}"
+        spans + "(#{lon_attr} BETWEEN #{sw_lng} AND 180 OR " +
+        "#{lon_attr} BETWEEN -180 AND #{ne_lng})"
       else
         spans + "#{lon_attr} BETWEEN #{sw_lng} AND #{ne_lng}"
       end

data/lib/geocoder/stores/active_record.rb

@@ -131,7 +131,11 @@ module Geocoder::Store
         distance_column = options.fetch(:distance_column) { 'distance' }
         bearing_column = options.fetch(:bearing_column)  { 'bearing' }
 
-        b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
+        # If radius is a DB column name, bounding box should include
+        # all rows within the maximum radius appearing in that column.
+        # Note: performance is dependent on variability of radii.
+        bb_radius = radius.is_a?(Symbol) ? maximum(radius) : radius
+        b = Geocoder::Calculations.bounding_box([latitude, longitude], bb_radius, options)
         args = b + [
           full_column_name(latitude_attribute),
           full_column_name(longitude_attribute)
@@ -142,7 +146,16 @@ module Geocoder::Store
           conditions = bounding_box_conditions
         else
           min_radius = options.fetch(:min_radius, 0).to_f
-          conditions = [bounding_box_conditions + " AND (#{distance}) BETWEEN ? AND ?", min_radius, radius]
+          # if radius is a DB column name,
+          # find rows between min_radius and value in column
+          if radius.is_a?(Symbol)
+            c = "BETWEEN ? AND #{radius}"
+            a = [min_radius]
+          else
+            c = "BETWEEN ? AND ?"
+            a = [min_radius, radius]
+          end
+          conditions = [bounding_box_conditions + " AND (#{distance}) " + c] + a
         end
         {
           :select => select_clause(options[:select],

data/lib/geocoder/stores/base.rb

@@ -113,4 +113,3 @@ module Geocoder
     end
   end
 end
-

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.4.4"
+  VERSION = "1.4.5"
 end

data/lib/tasks/geocoder.rake

@@ -1,4 +1,4 @@
-require "geocoder/models/mongoid" 
+require "geocoder/models/mongoid"
 
 namespace :geocode do
   desc "Geocode all objects without coordinates."
@@ -7,6 +7,7 @@ namespace :geocode do
     sleep_timer = ENV['SLEEP'] || ENV['sleep']
     batch = ENV['BATCH'] || ENV['batch']
     reverse = ENV['REVERSE'] || ENV['reverse']
+    limit = ENV['LIMIT'] || ENV['limit']
     raise "Please specify a CLASS (model)" unless class_name
     klass = class_from_string(class_name)
     batch = (batch.to_i unless batch.nil?) || 1000
@@ -20,13 +21,20 @@ namespace :geocode do
     }
 
     scope = reverse ? klass.not_reverse_geocoded : klass.not_geocoded
+    scope = scope.limit(limit) if limit
     if orm == 'mongoid'
       scope.each do |obj|
         geocode_record.call(obj)
       end
     elsif orm == 'active_record'
-      scope.find_each(batch_size: batch) do |obj|
-        geocode_record.call(obj)
+      if limit
+        scope.each do |obj|
+          geocode_record.call(obj)
+        end
+      else
+        scope.find_each(batch_size: batch) do |obj|
+          geocode_record.call(obj)
+        end
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geocoder
 version: !ruby/object:Gem::Version
-  version: 1.4.4
+  version: 1.4.5
 platform: ruby
 authors:
 - Alex Reisner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-17 00:00:00.000000000 Z
+date: 2017-11-29 00:00:00.000000000 Z
 dependencies: []
 description: Provides object geocoding (by street or IP address), reverse geocoding
   (coordinates to street address), distance queries for ActiveRecord and Mongoid,
@@ -35,6 +35,7 @@ files:
 - lib/generators/geocoder/maxmind/geolite_country_generator.rb
 - lib/generators/geocoder/maxmind/templates/migration/geolite_city.rb
 - lib/generators/geocoder/maxmind/templates/migration/geolite_country.rb
+- lib/generators/geocoder/migration_version.rb
 - lib/geocoder.rb
 - lib/geocoder/cache.rb
 - lib/geocoder/calculations.rb
@@ -53,6 +54,7 @@ files:
 - lib/geocoder/lookups/ban_data_gouv_fr.rb
 - lib/geocoder/lookups/base.rb
 - lib/geocoder/lookups/bing.rb
+- lib/geocoder/lookups/db_ip_com.rb
 - lib/geocoder/lookups/dstk.rb
 - lib/geocoder/lookups/esri.rb
 - lib/geocoder/lookups/freegeoip.rb
@@ -81,6 +83,7 @@ files:
 - lib/geocoder/lookups/opencagedata.rb
 - lib/geocoder/lookups/ovi.rb
 - lib/geocoder/lookups/pelias.rb
+- lib/geocoder/lookups/pickpoint.rb
 - lib/geocoder/lookups/pointpin.rb
 - lib/geocoder/lookups/postcode_anywhere_uk.rb
 - lib/geocoder/lookups/smarty_streets.rb
@@ -101,6 +104,7 @@ files:
 - lib/geocoder/results/ban_data_gouv_fr.rb
 - lib/geocoder/results/base.rb
 - lib/geocoder/results/bing.rb
+- lib/geocoder/results/db_ip_com.rb
 - lib/geocoder/results/dstk.rb
 - lib/geocoder/results/esri.rb
 - lib/geocoder/results/freegeoip.rb
@@ -129,6 +133,7 @@ files:
 - lib/geocoder/results/opencagedata.rb
 - lib/geocoder/results/ovi.rb
 - lib/geocoder/results/pelias.rb
+- lib/geocoder/results/pickpoint.rb
 - lib/geocoder/results/pointpin.rb
 - lib/geocoder/results/postcode_anywhere_uk.rb
 - lib/geocoder/results/smarty_streets.rb
@@ -149,7 +154,9 @@ files:
 homepage: http://www.rubygeocoder.com
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/alexreisner/geocoder
+  changelog_uri: https://github.com/alexreisner/geocoder/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths: