Newer
Older
Geocoder is a complete geocoding solution for Ruby. With Rails, it adds geocoding (by street or IP address), reverse geocoding (finding street address based on given coordinates), and distance queries. It's as simple as calling `geocode` on your objects, and then using a scope like `Venue.near("Billings, MT")`.
_Please note that this README is for the current `HEAD` and may document features not present in the latest gem release. For this reason, you may want to instead view the README for your [particular version](https://github.com/alexreisner/geocoder/releases)._
Compatibility
-------------
* Supports multiple Ruby versions: Ruby 1.9.3, 2.x, and JRuby.
* Supports multiple databases: MySQL, PostgreSQL, SQLite, and MongoDB (1.7.0 and higher).
* Supports Rails 3, 4, and 5. 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.
Note on Rails 4.1 and Greater
-----------------------------
Due to [a change in ActiveRecord's `count` method](https://github.com/rails/rails/pull/10710) you will need to use `count(:all)` to explicitly count all columns ("*") when using a `near` scope. Using `near` and calling `count` with no argument will cause exceptions in many cases.
Install Geocoder like any other Ruby gem:
gem install geocoder
Or, if you're using Rails/Bundler, add this to your Gemfile:
and run at the command prompt:
bundle install
Your model must have two attributes (database columns) for storing latitude and longitude coordinates. By default they should be called `latitude` and `longitude` but this can be changed (see "Model Configuration" below):
rails generate migration AddLatitudeAndLongitudeToModel latitude:float longitude:float
rake db:migrate
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`).
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
Next, your model must tell Geocoder which method returns your object's geocodable address:
geocoded_by :full_street_address # can also be an IP address
after_validation :geocode # auto-fetch coordinates
For reverse geocoding, tell Geocoder which attributes store latitude and longitude:
reverse_geocoded_by :latitude, :longitude
after_validation :reverse_geocode # auto-fetch address
### Mongoid
First, your model must have an array field for storing coordinates:
field :coordinates, :type => Array
You may also want an address field, like this:
field :address
but if you store address components (city, state, country, etc) in separate fields you can instead define a method called `address` that combines them into a single string which will be used to query the geocoding service.
Once your fields are defined, include the `Geocoder::Model::Mongoid` module and then call `geocoded_by`:
include Geocoder::Model::Mongoid
geocoded_by :address # can also be an IP address
after_validation :geocode # auto-fetch coordinates
Reverse geocoding is similar:
include Geocoder::Model::Mongoid
reverse_geocoded_by :coordinates
after_validation :reverse_geocode # auto-fetch address
Once you've set up your model you'll need to create the necessary spatial indices in your database:
rake db:mongoid:create_indexes
Be sure to read _Latitude/Longitude Order_ in the _Notes on MongoDB_ section below on how to properly retrieve latitude/longitude coordinates from your objects.
### MongoMapper
MongoMapper is very similar to Mongoid, just be sure to include `Geocoder::Model::MongoMapper`.
### Mongo Indices
By default, the methods `geocoded_by` and `reverse_geocoded_by` create a geospatial index. You can avoid index creation with the `:skip_index option`, for example:
include Geocoder::Model::Mongoid
geocoded_by :address, :skip_index => true
### Bulk Geocoding
If you have just added geocoding to an existing application with a lot of objects, you can use this Rake task to geocode them all:
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:
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:
* an address is present
* the address has been changed since last save (or it has never been saved)
The exact code will vary depending on the method you use for your geocodable string, but it would be something like this:
after_validation :geocode, if: ->(obj){ obj.address.present? and obj.address_changed? }
Request Geocoding by IP Address
-------------------------------
Geocoder adds `location` and `safe_location` methods to the standard `Rack::Request` object so you can easily look up the location of any HTTP request by IP address. For example, in a Rails controller or a Sinatra app:
# returns Geocoder::Result object
result = request.location
**The `location` method is vulnerable to trivial IP address spoofing via HTTP headers.** If that's a problem for your application, use `safe_location` instead, but be aware that `safe_location` will *not* try to trace a request's originating IP through proxy headers; you will instead get the location of the last proxy the request passed through, if any (excepting any proxies you have explicitly whitelisted in your Rack config).
Note that these methods will usually return `nil` in your test and development environments because things like "localhost" and "0.0.0.0" are not an Internet IP addresses.
See _Advanced Geocoding_ below for more information about `Geocoder::Result` objects.
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
Venue.near([40.71, -100.23], 20) # venues within 20 miles of a point
Venue.near([40.71, -100.23], 20, :units => :km)
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:
With geocoded objects you can do things like this:
if obj.geocoded?
obj.nearbys(30) # other objects within 30 miles
obj.distance_from([40.714,-100.234]) # distance from arbitrary point to object
obj.bearing_to("Paris, France") # direction from object to arbitrary point
end
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]
Please see the code for more methods and detailed information about arguments (eg, working with kilometers).
Distance and Bearing
--------------------
When you run a location-aware query the returned objects have two attributes added to them (only w/ ActiveRecord):
* `obj.distance` - number of miles from the search point to this object
Loading
Loading full blame...