geocoder 1.2.11 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5648fa768c84d9f5af64d9c377423d8c03567692
-  data.tar.gz: 670746d024b95d37411459e09bdffe69a8e50f65
+  metadata.gz: e7a2b3e33175d20be86a8eaf6c74d6178bc71991
+  data.tar.gz: d0dc03b689fbc43f16ae9395c7f743a3dd7876bd
 SHA512:
-  metadata.gz: 214ae40b18a556baca80fc3531cadd8250f87c22bd1c4f3e5d2227f3297754a13b799b40bb7833e02a9663162e85e427b48800f418211ad71243a1f6f204acfa
-  data.tar.gz: a1a399fbb540520d9e6ae4ffb4d4fa72318388f07746203340b972b5670753129ae52160f8673298a9a2732b31224761d88c00156ef954043c3332fdbc2634cf
+  metadata.gz: cb9f5c459af278bd20438a714475dece555b72222c34eab8c8fb61f6ddfc695848d330e9b84f366c8d67e5f253bda7d5e61020ab46382f8fbb40c8b7a9a58e82
+  data.tar.gz: ca02902240f5287a570ee05b0bc3b0300708200108b09543763e761ad1f0a2371355ef651471cdf96ce5cdabf104a39aedb04ef684e4f02aa3023911c27d7c4a

data/CHANGELOG.md

@@ -3,6 +3,29 @@ Changelog
 
 Major changes to Geocoder for each release. Please see the Git log for complete list of changes.
 
+1.3.0 (2016 Jan 31)
+-------------------
+* Lazy load lookups to reduce memory footprint (thanks github.com/TrangPham).
+* Add :geoportail_lu lookup (Luxembourg only) (thanks github.com/mdebo).
+* Maxmind local query performance improvement (thanks github.com/vojtad).
+* Remove deprecated Mongo near query methods (please use Mongo-native methods instead).
+
+1.2.14 (2015 Dec 27)
+--------------------
+* Fix bug in :geoip2 lookup (thanks github.com/mromulus).
+
+1.2.13 (2015 Dec 15)
+--------------------
+* Update :telize IP lookup to reflect new URL (thanks github.com/jfredrickson).
+* Add reverse geocode rake task (thanks github.com/FanaHOVA).
+* Fix reversed coordinates array with Mapbox (thanks github.com/marcusat).
+* Fix missing city name in some cases with ESRI (thanks github.com/roybotnik).
+* Prevent re-opening of DB file on every read with :geoip2 (thanks github.com/oogali).
+
+1.2.12 (2015 Oct 29)
+--------------------
+* Fix Ruby 1.9.3 incompatibility (remove non-existent timeout classes) (thanks github.com/roychri).
+
 1.2.11 (2015 Sep 10)
 --------------------
 * Fix load issue on Ruby 1.9.3.

data/README.md

@@ -9,7 +9,7 @@ _Please note that this README is for the current `HEAD` and may document feature
 Compatibility
 -------------
 
-* Supports multiple Ruby versions: Ruby 1.9.3, 2.0.x, 2.1.x, JRuby, and Rubinius.
+* Supports multiple Ruby versions: Ruby 1.9.3, 2.x, JRuby, and Rubinius.
 * Supports multiple databases: MySQL, PostgreSQL, SQLite, and MongoDB (1.7.0 and higher).
 * Supports Rails 3 and 4. If you need to use it with Rails 2 please see the `rails2` branch (no longer maintained, limited feature set).
 * Works very well outside of Rails, you just need to install either the `json` (for MRI) or `json_pure` (for JRuby) gem.
@@ -47,7 +47,7 @@ Your model must have two attributes (database columns) for storing latitude and
     rails generate migration AddLatitudeAndLongitudeToModel latitude:float longitude:float
     rake db:migrate
 
-For reverse geocoding your model must provide a method that returns an address. This can be a single attribute, but it can also be a method that returns a string assembled from different attributes (eg: `city`, `state`, and `country`).
+For geocoding your model must provide a method that returns an address. This can be a single attribute, but it can also be a method that returns a string assembled from different attributes (eg: `city`, `state`, and `country`).
 
 Next, your model must tell Geocoder which method returns your object's geocodable address:
 
@@ -106,6 +106,10 @@ If you have just added geocoding to an existing application with a lot of object
 
     rake geocode:all CLASS=YourModel
 
+If you need reverse geocoding instead, call the task with REVERSE=true:
+
+    rake geocode:all CLASS=YourModel REVERSE=true
+
 Geocoder will print warnings if you exceed the rate limit for your geocoding service. Some services — Google notably — enforce a per-second limit in addition to a per-day limit. To avoid exceeding the per-second limit, you can add a `SLEEP` option to pause between requests for a given amount of time. You can also load objects in batches to save memory, for example:
 
     rake geocode:all CLASS=YourModel SLEEP=0.25 BATCH=100
@@ -140,6 +144,12 @@ See _Advanced Geocoding_ below for more information about `Geocoder::Result` obj
 Location-Aware Database Queries
 -------------------------------
 
+### For Mongo-backed models:
+
+Please use MongoDB's [geospatial query language](https://docs.mongodb.org/manual/reference/command/geoNear/). Mongoid also provides [a DSL](http://mongoid.github.io/en/mongoid/docs/querying.html#geo_near) for doing near queries.
+
+### For ActiveRecord models:
+
 To find objects by location, use the following scopes:
 
     Venue.near('Omaha, NE, US', 20)    # venues within 20 miles of Omaha
@@ -149,6 +159,10 @@ To find objects by location, use the following scopes:
     Venue.geocoded                     # venues with coordinates
     Venue.not_geocoded                 # venues without coordinates
 
+by default, objects are ordered by distance. To remove the ORDER BY clause use the following:
+
+    Venue.near('Omaha', 20, :order => false)
+
 With geocoded objects you can do things like this:
 
     if obj.geocoded?
@@ -294,7 +308,7 @@ Every `Geocoder::Result` object, `result`, provides the following data:
 
 * `result.latitude` - float
 * `result.longitude` - float
-* `result.coordinates` - array of the above two
+* `result.coordinates` - array of the above two in the form of `[lat,lon]`
 * `result.address` - string
 * `result.city` - string
 * `result.state` - string
@@ -351,6 +365,10 @@ Please see the [source code for each lookup](https://github.com/alexreisner/geoc
     # with Nominatim:
     Geocoder.search("Paris", :params => {:countrycodes => "gb,de,fr,es,us"})
 
+Or, to search within a particular region with Google:
+
+    Geocoder.search("...", :params => {:region => "..."})
+
 You can also configure multiple geocoding services at once, like this:
 
     Geocoder.configure(
@@ -464,9 +482,9 @@ The [Google Places Details API](https://developers.google.com/places/documentati
 
 #### Yandex (`:yandex`)
 
-* **API key**: none
+* **API key**: optional, but without it lookup is territorially limited
 * **Quota**: 25000 requests / day
-* **Region**: world
+* **Region**: world with API key. Otherwise restricted to Russia, Ukraine, Belarus, Kazakhstan, Georgia, Abkhazia, South Ossetia, Armenia, Azerbaijan, Moldova, Turkmenistan, Tajikistan, Uzbekistan, Kyrgyzstan and Turkey
 * **SSL support**: HTTPS only
 * **Languages**: Russian, Belarusian, Ukrainian, English, Turkish (only for maps of Turkey)
 * **Documentation**: http://api.yandex.com.tr/maps/doc/intro/concepts/intro.xml
@@ -496,10 +514,24 @@ The [Google Places Details API](https://developers.google.com/places/documentati
 * **Terms of Service**: http://geocoder.us/terms.shtml
 * **Limitations**: ?
 
+#### Mapbox (`:mapbox`)
+
+* **API key**: required
+* **Dataset**: Uses `mapbox.places` dataset by default.  Specific the `mapbox.places-permanent` dataset by setting: `Geocoder.configure(:mapbox => {:dataset => "mapbox.places-permanent"})`
+* **Key signup**: https://www.mapbox.com/pricing/
+* **Quota**: depends on plan
+* **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
+* **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.
+* **Notes**: Currently in public beta.
+
 #### Mapquest (`:mapquest`)
 
 * **API key**: required
-* **Key signup**: http://developer.mapquest.com/web/products/open
+* **Key signup**: https://developer.mapquest.com/plans
 * **Quota**: ?
 * **HTTP Headers**: when using the licensed API you can specify a referer like so:
     `Geocoder.configure(:http_headers => { "Referer" => "http://foo.com" })`
@@ -605,6 +637,16 @@ Data Science Toolkit provides an API whose reponse format is like Google's but w
 * **Terms of Service**: http://www.itella.fi/liitteet/palvelutjatuotteet/yhteystietopalvelut/Postinumeropalvelut-Palvelukuvausjakayttoehdot.pdf
 * **Limitations**: ?
 
+#### Geoportail.lu (`:geoportail_lu`)
+
+* **API key**: none
+* **Quota**: none
+* **Region**: LU
+* **SSL support**: yes
+* **Languages**: en
+* **Documentation**: http://wiki.geoportail.lu/doku.php?id=en:api
+* **Terms of Service**: http://wiki.geoportail.lu/doku.php?id=en:mcg_1
+* **Limitations**: ?
 
 #### PostcodeAnywhere Uk (`:postcode_anywhere_uk`)
 
@@ -649,14 +691,15 @@ This uses the PostcodeAnywhere UK Geocode service, this will geocode any string
 
 #### Telize (`:telize`)
 
-* **API key**: none
-* **Quota**: none
+* **API key**: required
+* **Quota**: 1,000/day for $7/mo through 100,000/day for $100/mo
 * **Region**: world
-* **SSL support**: no
+* **SSL support**: yes
 * **Languages**: English
-* **Documentation**: http://www.telize.com/
+* **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")`.
 
 #### MaxMind Legacy Web Services (`:maxmind`)
 
@@ -891,6 +934,9 @@ Now, any time Geocoder looks up "New York, NY" its results array will contain on
       ]
     )
 
+Note:
+  Keys must be strings not symbols when calling `add_stub` or `set_default_stub`. For example `'latitude' =>` not `:latitude =>`.
+
 
 Command Line Interface
 ----------------------
@@ -1066,7 +1112,9 @@ If anyone has a more elegant solution to this problem I am very interested in se
 Contributing
 ------------
 
-Contributions are welcome via pull requests on Github. Please respect the following guidelines:
+Contributions are welcome via Github pull requests. If you are new to the project and looking for a way to get involved, try picking up an issue with a "beginner-task" label. Hints about what needs to be done are usually provided.
+
+For all contributions, please respect the following guidelines:
 
 * Each pull request should implement ONE feature or bugfix. If you want to add or fix more than one thing, submit more than one pull request.
 * Do not commit changes to files that are irrelevant to your feature or bugfix (eg: `.gitignore`).
@@ -1075,6 +1123,7 @@ Contributions are welcome via pull requests on Github. Please respect the follow
 * Remember: Geocoder needs to run outside of Rails. Don't assume things like ActiveSupport are available.
 * Be willing to accept criticism and work on improving your code; Geocoder is used by thousands of developers and care must be taken not to introduce bugs.
 * Be aware that the pull request review process is not immediate, and is generally proportional to the size of the pull request.
+* If your pull request is merged, please do not ask for an immediate release of the gem. There are many factors contributing to when releases occur (remember that they affect thousands of apps with Geocoder in their Gemfiles). If necessary, please install from the Github source until the next official release.
 
 
 Copyright (c) 2009-15 Alex Reisner, released under the MIT license

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

@@ -1,21 +1,21 @@
 Geocoder.configure(
-  # geocoding options
-  # :timeout      => 3,           # geocoding service timeout (secs)
-  # :lookup       => :google,     # name of geocoding service (symbol)
-  # :language     => :en,         # ISO-639 language code
-  # :use_https    => false,       # use HTTPS for lookup requests? (if supported)
-  # :http_proxy   => nil,         # HTTP proxy server (user:pass@host:port)
-  # :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 #keys)
-  # :cache_prefix => "geocoder:", # prefix (string) to use for all cache keys
+  # Geocoding options
+  # timeout: 3,                 # geocoding service timeout (secs)
+  # lookup: :google,            # name of geocoding service (symbol)
+  # language: :en,              # ISO-639 language code
+  # use_https: false,           # use HTTPS for lookup requests? (if supported)
+  # http_proxy: nil,            # HTTP proxy server (user:pass@host:port)
+  # 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 #keys)
+  # cache_prefix: 'geocoder:',  # prefix (string) to use for all cache keys
 
-  # exceptions that should not be rescued by default
+  # Exceptions that should not be rescued by default
   # (if you want to implement custom error handling);
   # supports SocketError and TimeoutError
-  # :always_raise => [],
+  # always_raise: [],
 
-  # calculation options
-  # :units     => :mi,       # :km for kilometers or :mi for miles
-  # :distances => :linear    # :spherical or :linear
+  # Calculation options
+  # units: :mi,                 # :km for kilometers or :mi for miles
+  # distances: :linear          # :spherical or :linear
 )

data/lib/geocoder/calculations.rb

@@ -237,11 +237,14 @@ module Geocoder
     #
     # * <tt>:units</tt> - <tt>:mi</tt> or <tt>:km</tt>
     #   Use Geocoder.configure(:units => ...) to configure default units.
+    # * <tt>:seed</tt> - The seed for the random number generator
     def random_point_near(center, radius, options = {})
 
       # set default options
       options[:units] ||= Geocoder.config.units
 
+      random = Random.new(options[:seed] || Random.new_seed)
+
       # convert to coordinate arrays
       center = extract_coordinates(center)
 
@@ -249,18 +252,18 @@ module Geocoder
       max_degree_delta =  360.0 * (radius / earth_circumference)
 
       # random bearing in radians
-      theta = 2 * Math::PI * rand
+      theta = 2 * Math::PI * random.rand
 
       # random radius, use the square root to ensure a uniform
       # distribution of points over the circle
-      r = Math.sqrt(rand) * max_degree_delta
+      r = Math.sqrt(random.rand) * max_degree_delta
 
       delta_lat, delta_long = [r * Math.cos(theta), r * Math.sin(theta)]
       [center[0] + delta_lat, center[1] + delta_long]
     end
 
     ##
-    # Given a start point, distance, and heading (in degrees), provides
+    # Given a start point, heading (in degrees), and distance, provides
     # an endpoint.
     # The starting point is given in the same way that points are given to all
     # Geocoder methods that accept points as arguments. It can be:

data/lib/geocoder/configuration.rb

@@ -125,6 +125,5 @@ module Geocoder
       end
       EOS
     end.join("\n\n"))
-
   end
 end

data/lib/geocoder/lookup.rb

@@ -1,3 +1,5 @@
+require "geocoder/lookups/test"
+
 module Geocoder
   module Lookup
     extend self
@@ -32,6 +34,7 @@ module Geocoder
         :geocoder_us,
         :yandex,
         :nominatim,
+        :mapbox,
         :mapquest,
         :opencagedata,
         :ovi,
@@ -41,6 +44,7 @@ module Geocoder
         :smarty_streets,
         :okf,
         :postcode_anywhere_uk,
+        :geoportail_lu,
         :test
       ]
     end
@@ -82,6 +86,8 @@ 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
       else
         valids = all_services.map(&:inspect).join(", ")
@@ -98,7 +104,3 @@ module Geocoder
     end
   end
 end
-
-Geocoder::Lookup.all_services.each do |name|
-  require "geocoder/lookups/#{name}"
-end

data/lib/geocoder/lookups/base.rb

@@ -190,7 +190,7 @@ module Geocoder
         else
           JSON.parse(data)
         end
-      rescue => err
+      rescue
         raise_error(ResponseParseError.new(data)) or Geocoder.log(:warn, "Geocoding API's response was not valid JSON: #{data}")
       end
 
@@ -283,7 +283,7 @@ module Geocoder
           end
           client.request(req)
         end
-      rescue Net::OpenTimeout, Net::ReadTimeout
+      rescue Timeout::Error
         raise Geocoder::LookupTimeout
       end
 

data/lib/geocoder/lookups/geoip2.rb

@@ -4,6 +4,8 @@ require 'geocoder/results/geoip2'
 module Geocoder
   module Lookup
     class Geoip2 < Base
+      attr_reader :gem_name
+
       def initialize
         unless configuration[:file].nil?
           begin
@@ -12,6 +14,8 @@ module Geocoder
           rescue LoadError
             raise "Could not load Maxmind DB dependency. To use the GeoIP2 lookup you must add the #{@gem_name} gem to your Gemfile or have it installed in your system."
           end
+
+          @mmdb = db_class.new(configuration[:file].to_s)
         end
         super
       end
@@ -26,13 +30,14 @@ module Geocoder
 
       private
 
+      def db_class
+        gem_name == 'hive_geoip2' ? Hive::GeoIP2 : MaxMindDB
+      end
+
       def results(query)
         return [] unless configuration[:file]
-        if @gem_name == 'hive_geoip2'
-          result = Hive::GeoIP2.lookup(query.to_s, configuration[:file].to_s)
-        else
-          result = MaxMindDB.new(configuration[:file].to_s).lookup(query.to_s)
-        end
+
+        result = @mmdb.lookup(query.to_s)
         result.nil? ? [] : [result]
       end
     end

data/lib/geocoder/lookups/geoportail_lu.rb

@@ -0,0 +1,65 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geoportail_lu"
+
+module Geocoder
+  module Lookup
+    class GeoportailLu < Base
+
+      def name
+        "Geoportail.lu"
+      end
+
+      def query_url(query)
+        url_base_path(query) + url_query_string(query)
+      end
+
+      private
+
+      def url_base_path(query)
+        query.reverse_geocode? ? reverse_geocode_url_base_path : search_url_base_path
+      end
+
+      def search_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/search?"
+      end
+
+      def reverse_geocode_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/reverseGeocode?"
+      end
+
+      def query_url_geoportail_lu_params(query)
+        query.reverse_geocode? ? reverse_geocode_params(query) : search_params(query)
+      end
+
+      def search_params(query)
+        {
+            queryString: query.sanitized_text
+        }
+      end
+
+      def reverse_geocode_params(query)
+        lat_lon = query.coordinates
+        {
+            lat: lat_lon.first,
+            lon: lat_lon.last
+        }
+      end
+
+      def query_url_params(query)
+        query_url_geoportail_lu_params(query).merge(super)
+      end
+
+      def results(query)
+        return [] unless doc = fetch_data(query)
+        if doc['success'] == true
+          result = doc['results']
+        else
+          result = []
+          raise_error(Geocoder::Error) ||
+              warn("Geportail.lu Geocoding API error")
+        end
+        result
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/mapbox.rb

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/mapbox"
+
+module Geocoder::Lookup
+  class Mapbox < Base
+
+    def name
+      "Mapbox"
+    end
+
+    def query_url(query)
+      "#{protocol}://api.mapbox.com/geocoding/v5/#{dataset}/#{url_query_string(query)}.json?access_token=#{configuration.api_key}"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless data = fetch_data(query)
+      if data['features']
+        sort_relevant_feature(data['features'])
+      elsif data['message'] =~ /Invalid\sToken/
+        raise_error(Geocoder::InvalidApiKey, data['message'])
+      else
+        []
+      end
+    end
+
+    def url_query_string(query)
+      require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        "#{CGI.escape lon},#{CGI.escape lat}"
+      else
+        CGI.escape query.text.to_s
+      end
+    end
+
+    def dataset
+      configuration[:dataset] || "mapbox.places"
+    end
+
+    def supported_protocols
+      [:https]
+    end
+
+    def sort_relevant_feature(features)
+      # Sort by descending relevance; Favor original order for equal relevance (eg occurs for reverse geocoding)
+      features.sort_by do |feature|
+        [feature["relevance"],-features.index(feature)]
+      end.reverse
+    end
+  end
+end

data/lib/geocoder/lookups/maxmind_local.rb

@@ -36,7 +36,7 @@ module Geocoder::Lookup
         addr = IPAddr.new(query.text).to_i
         q = "SELECT l.country, l.region, l.city, l.latitude, l.longitude
           FROM maxmind_geolite_city_location l WHERE l.loc_id = (SELECT b.loc_id FROM maxmind_geolite_city_blocks b
-          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num LIMIT 1)"
+          WHERE b.start_ip_num <= #{addr} AND #{addr} <= b.end_ip_num)"
         format_result(q, [:country_name, :region_name, :city_name, :latitude, :longitude])
       elsif configuration[:package] == :country
         addr = IPAddr.new(query.text).to_i

data/lib/geocoder/lookups/telize.rb

@@ -8,13 +8,16 @@ module Geocoder::Lookup
       "Telize"
     end
 
+    def required_api_key_parts
+      ["key"]
+    end
+
     def query_url(query)
-      "#{protocol}://www.telize.com/geoip/#{query.sanitized_text}"
+      "#{protocol}://telize-v1.p.mashape.com/geoip/#{query.sanitized_text}?mashape-key=#{api_key}"
     end
 
-    # currently doesn't support HTTPS
     def supported_protocols
-      [:http]
+      [:https]
     end
 
     private # ---------------------------------------------------------------
@@ -36,5 +39,9 @@ module Geocoder::Lookup
     def reserved_result(ip)
       {"message" => "Input string is not a valid IP address", "code" => 401}
     end
+
+    def api_key
+      configuration.api_key
+    end
   end
 end

data/lib/geocoder/results/esri.rb

@@ -4,12 +4,16 @@ module Geocoder::Result
   class Esri < Base
 
     def address
-      address = reverse_geocode? ? 'Address' : 'Match_addr'
-      attributes[address]
+      address_key = reverse_geocode? ? 'Address' : 'Match_addr'
+      attributes[address_key]
     end
 
     def city
-      attributes['City']
+      if !reverse_geocode? && is_city?
+        place_name
+      else
+        attributes['City']
+      end
     end
 
     def state_code
@@ -19,8 +23,8 @@ module Geocoder::Result
     alias_method :state, :state_code
 
     def country
-      country = reverse_geocode? ? "CountryCode" : "Country"
-      attributes[country]
+      country_key = reverse_geocode? ? "CountryCode" : "Country"
+      attributes[country_key]
     end
 
     alias_method :country_code, :country
@@ -29,6 +33,15 @@ module Geocoder::Result
       attributes['Postal']
     end
 
+    def place_name
+      place_name_key = reverse_geocode? ? "Address" : "PlaceName"
+      attributes[place_name_key]
+    end
+
+    def place_type
+      reverse_geocode? ? "Address" : attributes['Type']
+    end
+
     def coordinates
       [geometry["y"], geometry["x"]]
     end
@@ -47,5 +60,8 @@ module Geocoder::Result
       @data['locations'].nil?
     end
 
+    def is_city?
+      ['City', 'State Capital', 'National Capital'].include?(place_type)
+    end
   end
-end
+end

data/lib/geocoder/results/geoip2.rb

@@ -13,35 +13,35 @@ module Geocoder
       end
 
       def latitude
-        data.fetch('location',{}).fetch('latitude',0.0)
+        data.fetch('location', {}).fetch('latitude', 0.0)
       end
 
       def longitude
-        data.fetch('location',{}).fetch('longitude',0.0)
+        data.fetch('location', {}).fetch('longitude', 0.0)
       end
 
       def city
-        data.fetch('city', {}).fetch('names', {}).fetch('en', '')
+        data.fetch('city', {}).fetch('names', {}).fetch(locale, '')
       end
 
       def state
-        data.fetch('subdivisions',[]).fetch(0,{}).fetch('names',{}).fetch('en','')
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('names', {}).fetch(locale, '')
       end
 
       def state_code
-        data.fetch('subdivisions',[]).fetch(0,{}).fetch('iso_code','')
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('iso_code', '')
       end
 
       def country
-        data.fetch('country', {}).fetch('names',{}).fetch('en','')
+        data.fetch('country', {}).fetch('names', {}).fetch(locale, '')
       end
 
       def country_code
-        data.fetch('country',{}).fetch('iso_code','')
+        data.fetch('country', {}).fetch('iso_code', '')
       end
 
       def postal_code
-        data.fetch('postal',{}).fetch('code','')
+        data.fetch('postal', {}).fetch('code', '')
       end
 
       def self.response_attributes
@@ -59,6 +59,10 @@ module Geocoder
       def data
         @data.to_hash
       end
+
+      def locale
+        @locale ||= Geocoder.config[:language].to_s
+      end
     end
   end
 end

data/lib/geocoder/results/geoportail_lu.rb

@@ -0,0 +1,69 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeoportailLu < Base
+
+    def coordinates
+      geomlonlat['coordinates'].reverse if geolocalized?
+    end
+
+    def address
+      full_address
+    end
+
+    def city
+      try_to_extract 'locality', detailled_address
+    end
+
+    def state
+      'Luxembourg'
+    end
+
+    def state_code
+      'LU'
+    end
+
+    def postal_code
+      try_to_extract 'zip', detailled_address
+    end
+
+    def street_address
+      [street_number, street].compact.join(' ')
+    end
+
+    def street_number
+      try_to_extract 'postnumber', detailled_address
+    end
+
+    def street
+      try_to_extract 'street', detailled_address
+    end
+
+    def full_address
+      data['address']
+    end
+
+    def geomlonlat
+      data['geomlonlat']
+    end
+
+    def detailled_address
+      data['AddressDetails']
+    end
+
+    alias_method :country, :state
+    alias_method :province, :state
+    alias_method :country_code, :state_code
+    alias_method :province_code, :state_code
+
+    private
+
+    def geolocalized?
+      try_to_extract('coordinates', geomlonlat).present?
+    end
+
+    def try_to_extract(key, nullable_hash)
+      nullable_hash.try(:[], key)
+    end
+  end
+end

data/lib/geocoder/results/google.rb

@@ -120,5 +120,13 @@ module Geocoder::Result
     def precision
       geometry['location_type'] if geometry
     end
+    
+    def partial_match
+      @data['partial_match']
+    end
+    
+    def place_id
+      @data['place_id']
+    end  
   end
 end

data/lib/geocoder/results/mapbox.rb

@@ -0,0 +1,55 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Mapbox < Base
+
+    def latitude
+      @latitude ||= @data["geometry"]["coordinates"].last.to_f
+    end
+
+    def longitude
+      @longitude ||= @data["geometry"]["coordinates"].first.to_f
+    end
+
+    def coordinates
+      [latitude, longitude]
+    end
+
+    def place_name
+      @data['text']
+    end
+
+    def street
+      @data['properties']['address']
+    end
+
+    def city
+      @data['context'].map { |c| c['text'] if c['id'] =~ /place/ }.compact.first
+    end
+
+    def state
+      @data['context'].map { |c| c['text'] if c['id'] =~ /region/ }.compact.first
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['context'].map { |c| c['text'] if c['id'] =~ /postcode/ }.compact.first
+    end
+
+    def country
+      @data['context'].map { |c| c['text'] if c['id'] =~ /country/ }.compact.first
+    end
+
+    alias_method :country_code, :country
+
+    def neighborhood
+      @data['context'].map { |c| c['text'] if c['id'] =~ /neighborhood/ }.compact.first
+    end
+
+    def address
+      [place_name, street, city, state, postal_code, country].compact.join(", ")
+    end
+  end
+end
+

data/lib/geocoder/results/mapquest.rb

@@ -26,6 +26,10 @@ module Geocoder::Result
       @data['adminArea3']
     end
 
+    def county
+      @data['adminArea4']
+    end
+
     alias_method :state_code, :state
 
     #FIXME: these might not be right, unclear with MQ documentation

data/lib/geocoder/results/pointpin.rb

@@ -23,10 +23,6 @@ module Geocoder::Result
       @data['country_name']
     end
 
-    def country_code
-      @data['country_code']
-    end
-
     def postal_code
       @data['postcode']
     end

data/lib/geocoder/stores/active_record.rb

@@ -28,6 +28,11 @@ module Geocoder::Store
             "OR #{table_name}.#{geocoder_options[:longitude]} IS NULL")
         }
 
+        # scope: not-reverse geocoded objects
+        scope :not_reverse_geocoded, lambda {
+          where("#{table_name}.#{geocoder_options[:fetched_address]} IS NULL")
+        }
+
         ##
         # Find all objects within a radius of the given location.
         # Location may be either a string to geocode or an array of

data/lib/geocoder/stores/mongo_base.rb

@@ -11,38 +11,6 @@ module Geocoder::Store
         scope :not_geocoded, lambda {
           where(geocoder_options[:coordinates] => nil)
         }
-
-        scope :near, lambda{ |location, *args|
-          warn "DEPRECATION WARNING: The .near method will be removed for MongoDB-backed models in Geocoder 1.3.0. Please use MongoDB's built-in query language instead."
-          coords  = Geocoder::Calculations.extract_coordinates(location)
-
-          # no results if no lat/lon given
-          return where(:id => false) unless coords.is_a?(Array)
-
-          radius  = args.size > 0 ? args.shift : 20
-          options = args.size > 0 ? args.shift : {}
-          options[:units] ||= geocoder_options[:units]
-
-          # Use BSON::OrderedHash if Ruby's hashes are unordered.
-          # Conditions must be in order required by indexes (see mongo gem).
-          version = RUBY_VERSION.split('.').map { |i| i.to_i }
-          empty = version[0] < 2 && version[1] < 9 ? BSON::OrderedHash.new : {}
-
-          conds = empty.clone
-          field = geocoder_options[:coordinates]
-          conds[field] = empty.clone
-          conds[field]["$nearSphere"]  = coords.reverse
-
-          if radius
-            conds[field]["$maxDistance"] = \
-              Geocoder::Calculations.distance_to_radians(radius, options[:units])
-          end
-
-          if obj = options[:exclude]
-            conds[:_id.ne] = obj.id
-          end
-          where(conds)
-        }
       end
     end
 
@@ -56,18 +24,6 @@ module Geocoder::Store
       coords.is_a?(Array) ? coords.reverse : []
     end
 
-    ##
-    # Get nearby geocoded objects.
-    # Takes the same options hash as the near class method (scope).
-    # Returns nil if the object is not geocoded.
-    #
-    def nearbys(radius = 20, options = {})
-      warn "DEPRECATION WARNING: The #nearbys method will be removed for MongoDB-backed models in Geocoder 1.3.0. Please use MongoDB's built-in query language instead."
-      return nil unless geocoded?
-      options.merge!(:exclude => self) unless send(self.class.primary_key).nil?
-      self.class.near(self, radius, options)
-    end
-
     ##
     # Look up coordinates and assign to +latitude+ and +longitude+ attributes
     # (or other as specified in +geocoded_by+). Returns coordinates (array).

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.2.11"
+  VERSION = "1.3.0"
 end

data/lib/maxmind_database.rb

@@ -21,7 +21,7 @@ module Geocoder
     end
 
     def insert(package, dir = "tmp")
-      data_files(package).each do |filepath,table|
+      data_files(package, dir).each do |filepath,table|
         print "Resetting table #{table}..."
         ActiveRecord::Base.connection.execute("DELETE FROM #{table}")
         puts "done"

data/lib/tasks/geocoder.rake

@@ -4,13 +4,22 @@ namespace :geocode do
     class_name = ENV['CLASS'] || ENV['class']
     sleep_timer = ENV['SLEEP'] || ENV['sleep']
     batch = ENV['BATCH'] || ENV['batch']
+    reverse = ENV['REVERSE'] || ENV['reverse']
     raise "Please specify a CLASS (model)" unless class_name
     klass = class_from_string(class_name)
     batch = batch.to_i unless batch.nil?
+    reverse = false unless reverse.to_s.downcase == 'true'
 
-    klass.not_geocoded.find_each(batch_size: batch) do |obj|
-      obj.geocode; obj.save
-      sleep(sleep_timer.to_f) unless sleep_timer.nil?
+    if reverse
+      klass.not_reverse_geocoded.find_each(batch_size: batch) do |obj|
+        obj.reverse_geocode; obj.save
+        sleep(sleep_timer.to_f) unless sleep_timer.nil?
+      end
+    else
+      klass.not_geocoded.find_each(batch_size: batch) do |obj|
+        obj.geocode; obj.save
+        sleep(sleep_timer.to_f) unless sleep_timer.nil?
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geocoder
 version: !ruby/object:Gem::Version
-  version: 1.2.11
+  version: 1.3.0
 platform: ruby
 authors:
 - Alex Reisner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-10 00:00:00.000000000 Z
+date: 2016-01-31 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,
@@ -57,10 +57,12 @@ files:
 - lib/geocoder/lookups/geocoder_us.rb
 - lib/geocoder/lookups/geocodio.rb
 - lib/geocoder/lookups/geoip2.rb
+- lib/geocoder/lookups/geoportail_lu.rb
 - lib/geocoder/lookups/google.rb
 - lib/geocoder/lookups/google_places_details.rb
 - lib/geocoder/lookups/google_premier.rb
 - lib/geocoder/lookups/here.rb
+- lib/geocoder/lookups/mapbox.rb
 - lib/geocoder/lookups/mapquest.rb
 - lib/geocoder/lookups/maxmind.rb
 - lib/geocoder/lookups/maxmind_geoip2.rb
@@ -95,10 +97,12 @@ files:
 - lib/geocoder/results/geocoder_us.rb
 - lib/geocoder/results/geocodio.rb
 - lib/geocoder/results/geoip2.rb
+- lib/geocoder/results/geoportail_lu.rb
 - lib/geocoder/results/google.rb
 - lib/geocoder/results/google_places_details.rb
 - lib/geocoder/results/google_premier.rb
 - lib/geocoder/results/here.rb
+- lib/geocoder/results/mapbox.rb
 - lib/geocoder/results/mapquest.rb
 - lib/geocoder/results/maxmind.rb
 - lib/geocoder/results/maxmind_geoip2.rb
@@ -146,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Complete geocoding solution for Ruby.