taylor-jaydee
geocoder

Repository

gem install geocoder
gem 'geocoder'
bundle install
geocoded_by :address

def address
  [street, city, state, country].compact.join(', ')
end
geocoded_by :address               # can also be an IP address
after_validation :geocode          # auto-fetch coordinates
reverse_geocoded_by :latitude, :longitude
after_validation :reverse_geocode  # auto-fetch address
field :coordinates, :type => Array
field :address
include Geocoder::Model::Mongoid
geocoded_by :address               # can also be an IP address
after_validation :geocode          # auto-fetch coordinates
include Geocoder::Model::Mongoid
reverse_geocoded_by :coordinates
after_validation :reverse_geocode  # auto-fetch address
rake db:mongoid:create_indexes
obj.to_coordinates  # => [37.7941013, -122.3951096] # [lat, lon]
obj.coordinates     # => [-122.3951096, 37.7941013] # [lon, lat]
# returns Geocoder::Result object
result = request.location
Venue.near('Omaha, NE, US')        # venues within 20 (default) miles of Omaha
Venue.near([40.71, -100.23], 50)   # venues within 50 miles of a point
Venue.near([40.71, -100.23], 50, :units => :km)
                                   # venues within 50 kilometres of a point
Venue.geocoded                     # venues with coordinates
Venue.not_geocoded                 # venues without coordinates
Venue.near('Omaha', 20, :order => false)
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
# 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]
geocoded_by :address, :latitude  => :lat, :longitude => :lon # ActiveRecord
geocoded_by :address, :coordinates => :coords                # MongoDB
reverse_geocoded_by :latitude, :longitude, :address => :location  # ActiveRecord
reverse_geocoded_by :coordinates, :address => :loc                # MongoDB
rails generate geocoder:config
# config/initializers/geocoder.rb
Geocoder.configure(

  # street address geocoding service (default :google)
  :lookup => :yandex,

  # IP address geocoding service (default :ipinfo_io)
  :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](#caching) for details):
  :cache => Redis.new,
  :cache_prefix => "..."

)
# with Google:
Geocoder.search("Paris", :bounds => [[32.1,-95.9], [33.9,-94.3]])
# with Nominatim:
Geocoder.search("Paris", :params => {:countrycodes => "gb,de,fr,es,us"})
Geocoder.search("...", :params => {:region => "..."})
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
geocoded_by :address, :lookup => lambda{ |obj| obj.geocoder_lookup }

def geocoder_lookup
  if country_code == "RU"
    :yandex
  elsif country_code == "CN"
    :baidu
  else
    :google
  end
end
Geocoder.configure(

  :timeout => 2,
  :cache => Redis.new,

  :yandex => {
    :api_key => "...",
    :timeout => 5
  },

  :baidu => {
    :api_key => "..."
  },

  :maxmind => {
    :api_key => "...",
    :service => :omni
  }

)
Geocoder.configure(ip_lookup: :maxmind_local, maxmind_local: {file: File.join('folder', 'GeoLiteCity.dat')})
Geocoder.configure(ip_lookup: :maxmind_local, maxmind_local: {package: :city})
# generate migration to create tables
rails generate geocoder:maxmind:geolite_city

# download, unpack, and import data
rake geocoder:maxmind:geolite:load PACKAGE=city
Geocoder.configure(
  ip_lookup: :geoip2,
  geoip2: {
    lib: 'hive_geoip2',
    file: File.join('folder', 'GeoLite2-City.mmdb')
  }
)
add_index :table, [:latitude, :longitude]
include Geocoder::Model::Mongoid
geocoded_by :address, :skip_index => true
after_validation :geocode, if: ->(obj){ obj.address.present? and obj.address_changed? }
Geocoder.configure(:cache => Redis.new)
Geocoder.configure(:cache_prefix => "...")
Geocoder::Lookup.get(Geocoder.config[:lookup]).cache.expire(:all)  # expire cached results for current Lookup
Geocoder::Lookup.get(:google).cache.expire("http://...")           # expire cached result for a specific URL
Geocoder::Lookup.get(:google).cache.expire(:all)                   # expire cached results for Google Lookup
# expire all cached results for all Lookups.
# Be aware that this methods spawns a new Lookup object for each Service
Geocoder::Lookup.all_services.each{|service| Geocoder::Lookup.get(service).cache.expire(:all)}
reverse_geocoded_by :latitude, :longitude do |obj,results|
  if geo = results.first
    obj.city    = geo.city
    obj.zipcode = geo.postal_code
    obj.country = geo.country_code
  end
end
after_validation :reverse_geocode
class Venue

  # 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
class Venue
  geocoded_by :address,
    :latitude  => :fetched_latitude,
    :longitude => :fetched_longitude
  reverse_geocoded_by :latitude, :longitude
end
rake geocode:all CLASS=YourModel
rake geocode:all CLASS=YourModel REVERSE=true
rake geocode:all CLASS=YourModel SLEEP=0.25 BATCH=100
rake geocode:all CLASS=YourModel LIMIT=1000
distance = 20
center_point = [40.71, 100.23]
box = Geocoder::Calculations.bounding_box(center_point, distance)
Venue.within_bounding_box(box)
box = Geocoder::Calculations.bounding_box(center_point, distance, :min_radius => 10.5)
Venue.near("Paris", 50, latitude: :secondary_latitude, longitude: :secondary_longitude)
Geocoder::Calculations.compass_point(355) # => "N"
Geocoder::Calculations.compass_point(45)  # => "NE"
Geocoder::Calculations.compass_point(208) # => "SW"
obj.distance_to([43.9,-98.6])  # distance from obj to point
obj.bearing_to([43.9,-98.6])   # bearing from obj to point
obj.bearing_from(obj2)         # bearing from obj2 to obj
Geocoder.configure(:lookup => :test)

Geocoder::Lookup::Test.add_stub(
  "New York, NY", [
    {
      'coordinates'  => [40.7143528, -74.0059731],
      'address'      => 'New York, NY, USA',
      'state'        => 'New York',
      'state_code'   => 'NY',
      'country'      => 'United States',
      'country_code' => 'US'
    }
  ]
)
Geocoder.configure(:lookup => :test)

Geocoder::Lookup::Test.set_default_stub(
  [
    {
      'coordinates'  => [40.7143528, -74.0059731],
      'address'      => 'New York, NY, USA',
      'state'        => 'New York',
      'state_code'   => 'NY',
      'country'      => 'United States',
      'country_code' => 'US'
    }
  ]
)
Geocoder.configure(:always_raise => [SocketError, Timeout::Error])
Geocoder.configure(:always_raise => :all)
SocketError
Timeout::Error
Geocoder::OverQueryLimitError
Geocoder::RequestDenied
Geocoder::InvalidRequest
Geocoder::InvalidApiKey
Geocoder::ServiceUnavailable
results = Geocoder.search("McCarren Park, Brooklyn, NY")
extend Geocoder::Model::ActiveRecord
$ geocode 29.951,-90.081
Latitude:         29.952211
Longitude:        -90.080563
Full address:     1500 Sugar Bowl Dr, New Orleans, LA 70112, USA
City:             New Orleans
State/province:   Louisiana
Postal code:      70112
Country:          United States
Google map:       http://maps.google.com/maps?q=29.952211,-90.080563
uninitialized constant Geocoder::Model::Mongoid
uninitialized constant Geocoder::Model::Mongoid::Mongo
Geocoder::Lookup.get(:google).query_url(Geocoder::Query.new("..."))
Geocoder::Lookup.get(:google).send(:fetch_raw_data, Geocoder::Query.new("..."))
# 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:
Hotel.near("London, UK", 50).joins(:administrator).preload(:administrator)