geocoder 1.1.9 → 1.3.7

data/examples/reverse_geocode_job.rb

@@ -0,0 +1,40 @@
+# This class implements an ActiveJob job for performing reverse-geocoding
+# asynchronously. Example usage:
+
+# if @location.save && @location.address.blank?
+#   ReverseGeocodeJob.perform_later(@location)
+# end
+
+# Be sure to configure the queue adapter in config/application.rb:
+# config.active_job.queue_adapter = :sidekiq
+
+# You can read the Rails docs for more information on configuring ActiveJob:
+# http://edgeguides.rubyonrails.org/active_job_basics.html
+
+class ReverseGeocodeJob < ActiveJob::Base
+  queue_as :high
+
+  def perform(location)
+    address = address(location)
+
+    if address.present?
+      location.update(address: address)
+    end
+  end
+
+  private
+
+  def address(location)
+    Geocoder.address(location.coordinates)
+  rescue => exception
+    MonitoringService.notify(exception, location: { id: location.id })
+
+    if retryable?(exception)
+      raise exception
+    end
+  end
+
+  def retryable?(exception)
+    exception.is_a?(Timeout::Error) || exception.is_a?(SocketError)
+  end
+end

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 => [],
+  # supports SocketError and Timeout::Error
+  # 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/generators/geocoder/maxmind/geolite_city_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/migration'
+
+module Geocoder
+  module Generators
+    module Maxmind
+      class GeoliteCityGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+
+        source_root File.expand_path('../templates', __FILE__)
+
+        def copy_migration_files
+          migration_template "migration/geolite_city.rb", "db/migrate/geocoder_maxmind_geolite_city.rb"
+        end
+
+        # Define the next_migration_number method (necessary for the
+        # migration_template method to work)
+        def self.next_migration_number(dirname)
+          if ActiveRecord::Base.timestamped_migrations
+            sleep 1 # make sure each time we get a different timestamp
+            Time.new.utc.strftime("%Y%m%d%H%M%S")
+          else
+            "%.3d" % (current_migration_number(dirname) + 1)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'rails/generators/migration'
+
+module Geocoder
+  module Generators
+    module Maxmind
+      class GeoliteCountryGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+
+        source_root File.expand_path('../templates', __FILE__)
+
+        def copy_migration_files
+          migration_template "migration/geolite_country.rb", "db/migrate/geocoder_maxmind_geolite_country.rb"
+        end
+
+        # Define the next_migration_number method (necessary for the
+        # migration_template method to work)
+        def self.next_migration_number(dirname)
+          if ActiveRecord::Base.timestamped_migrations
+            sleep 1 # make sure each time we get a different timestamp
+            Time.new.utc.strftime("%Y%m%d%H%M%S")
+          else
+            "%.3d" % (current_migration_number(dirname) + 1)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+class GeocoderMaxmindGeoliteCity < ActiveRecord::Migration
+  def self.up
+    create_table :maxmind_geolite_city_blocks, id: false do |t|
+      t.column :start_ip_num, :bigint, null: false
+      t.column :end_ip_num, :bigint, null: false
+      t.column :loc_id, :bigint, null: false
+    end
+    add_index :maxmind_geolite_city_blocks, :loc_id
+    add_index :maxmind_geolite_city_blocks, :start_ip_num, unique: true
+    add_index :maxmind_geolite_city_blocks, [:end_ip_num, :start_ip_num], unique: true, name: 'index_maxmind_geolite_city_blocks_on_end_ip_num_range'
+
+    create_table :maxmind_geolite_city_location, id: false do |t|
+      t.column :loc_id, :bigint, null: false
+      t.string :country, null: false
+      t.string :region, null: false
+      t.string :city
+      t.string :postal_code, null: false
+      t.float :latitude
+      t.float :longitude
+      t.integer :metro_code
+      t.integer :area_code
+    end
+    add_index :maxmind_geolite_city_location, :loc_id, unique: true
+  end
+
+  def self.down
+    drop_table :maxmind_geolite_city_location
+    drop_table :maxmind_geolite_city_blocks
+  end
+end

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

@@ -0,0 +1,17 @@
+class GeocoderMaxmindGeoliteCountry < ActiveRecord::Migration
+  def self.up
+    create_table :maxmind_geolite_country, id: false do |t|
+      t.column :start_ip, :string
+      t.column :end_ip, :string
+      t.column :start_ip_num, :bigint, null: false
+      t.column :end_ip_num, :bigint, null: false
+      t.column :country_code, :string, null: false
+      t.column :country, :string, null: false
+    end
+    add_index :maxmind_geolite_country, :start_ip_num, unique: true
+  end
+
+  def self.down
+    drop_table :maxmind_geolite_country
+  end
+end

data/lib/geocoder/cache.rb

@@ -49,7 +49,8 @@ module Geocoder
 
     private # ----------------------------------------------------------------
 
-    attr_reader :prefix, :store
+    def prefix; @prefix; end
+    def store; @store; end
 
     ##
     # Cache key for a given URL.
@@ -63,7 +64,7 @@ module Geocoder
     # that have non-nil values.
     #
     def keys
-      store.keys.select{ |k| k.match /^#{prefix}/ and interpret(store[k]) }
+      store.keys.select{ |k| k.match(/^#{prefix}/) and interpret(store[k]) }
     end
 
     ##

data/lib/geocoder/calculations.rb

@@ -26,6 +26,11 @@ module Geocoder
     #
     KM_IN_NM = 0.539957
 
+    ##
+    # Conversion factor: multiply by radians to get degrees.
+    #
+    DEGREES_PER_RADIAN = 57.2957795
+
     # Not a number constant
     NAN = defined?(::Float::NAN) ? ::Float::NAN : 0 / 0.0
 
@@ -232,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)
 
@@ -244,16 +252,50 @@ 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, 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:
+    #
+    # * an array of coordinates ([lat,lon])
+    # * a geocodable address (string)
+    # * a geocoded object (one which implements a +to_coordinates+ method
+    #   which returns a [lat,lon] array
+    #
+    def endpoint(start, heading, distance, options = {})
+      options[:units] ||= Geocoder.config.units
+      radius = earth_radius(options[:units])
+
+      start = extract_coordinates(start)
+
+      # convert degrees to radians
+      start = to_radians(start)
+
+      lat = start[0]
+      lon = start[1]
+      heading = to_radians(heading)
+      distance = distance.to_f
+
+      end_lat = Math.asin(Math.sin(lat)*Math.cos(distance/radius) +
+                    Math.cos(lat)*Math.sin(distance/radius)*Math.cos(heading))
+
+      end_lon = lon+Math.atan2(Math.sin(heading)*Math.sin(distance/radius)*Math.cos(lat),
+                    Math.cos(distance/radius)-Math.sin(lat)*Math.sin(end_lat))
+
+      to_degrees [end_lat, end_lon]
+    end
+
     ##
     # Convert degrees to radians.
     # If an array (or multiple arguments) is passed,

data/lib/geocoder/configuration.rb

@@ -14,14 +14,8 @@ module Geocoder
   #   )
   #
   def self.configure(options = nil, &block)
-    if block_given?
-      warn "WARNING: Passing a block to Geocoder.configure is DEPRECATED. Please pass a hash instead (eg: Geocoder.configure(:units => ..., :api_key => ...))."
-      block.call(Configuration.instance)
-    elsif !options.nil?
+    if !options.nil?
       Configuration.instance.configure(options)
-    else
-      warn "WARNING: Use of Geocoder.configure to read or write single config options is DEPRECATED. To write to the config please pass a hash (eg: Geocoder.configure(:units => ...)). To read config options please use the Geocoder.config object (eg: Geocoder.config.units)."
-      Configuration.instance
     end
   end
 
@@ -44,6 +38,14 @@ module Geocoder
     data
   end
 
+  ##
+  # Merge the given hash into a lookup's existing configuration.
+  #
+  def self.merge_into_lookup_config(lookup_name, options)
+    base = Geocoder.config[lookup_name]
+    Geocoder.configure(lookup_name => base.merge(options))
+  end
+
   class Configuration
     include Singleton
 
@@ -61,7 +63,10 @@ module Geocoder
       :cache_prefix,
       :always_raise,
       :units,
-      :distances
+      :distances,
+      :basic_auth,
+      :logger,
+      :kernel_logger_level
     ]
 
     attr_accessor :data
@@ -102,10 +107,13 @@ module Geocoder
       @data[:api_key]      = nil         # API key for geocoding service
       @data[:cache]        = nil         # cache object (must respond to #[], #[]=, and #keys)
       @data[:cache_prefix] = "geocoder:" # 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
 
       # exceptions that should not be rescued by default
       # (if you want to implement custom error handling);
-      # supports SocketError and TimeoutError
+      # supports SocketError and Timeout::Error
       @data[:always_raise] = []
 
       # calculation options
@@ -125,6 +133,5 @@ module Geocoder
       end
       EOS
     end.join("\n\n"))
-
   end
 end

data/lib/geocoder/esri_token.rb

@@ -0,0 +1,38 @@
+module Geocoder
+  class EsriToken
+    attr_accessor :value, :expires_at
+
+    def initialize(value, expires_at)
+      @value = value
+      @expires_at = expires_at
+    end
+
+    def to_s
+        @value
+    end
+
+    def active?
+      @expires_at > Time.now
+    end
+
+    def self.generate_token(client_id, client_secret, expires=1440)
+      # creates a new token that will expire in 1 day by default
+      getToken = Net::HTTP.post_form URI('https://www.arcgis.com/sharing/rest/oauth2/token'),
+        f: 'json',
+        client_id: client_id,
+        client_secret: client_secret,
+        grant_type: 'client_credentials',
+        expiration: expires # (minutes) max: 20160, default: 1 day
+
+      response = JSON.parse(getToken.body)
+
+      if response['error']
+        Geocoder.log(:warn, response['error'])
+      else
+        token_value = response['access_token']
+        expires_at = Time.now + (expires * 60)
+        new(token_value, expires_at)
+      end
+    end
+  end
+end

data/lib/geocoder/exceptions.rb

@@ -1,3 +1,5 @@
+require 'timeout' # required for Ruby 1.9.3
+
 module Geocoder
 
   class Error < StandardError
@@ -9,6 +11,14 @@ module Geocoder
   class OverQueryLimitError < Error
   end
 
+  class ResponseParseError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+  end
+
   class RequestDenied < Error
   end
 
@@ -18,4 +28,13 @@ module Geocoder
   class InvalidApiKey < Error
   end
 
+  class ServiceUnavailable < Error
+  end
+
+  class LookupTimeout < ::Timeout::Error
+  end
+
+  class NetworkError < Error
+  end
+
 end

data/lib/geocoder/ip_address.rb

@@ -0,0 +1,13 @@
+require 'resolv'
+module Geocoder
+  class IpAddress < String
+
+    def loopback?
+      valid? and (self == "0.0.0.0" or self.match(/\A127\./) or self == "::1")
+    end
+
+    def valid?
+      !!((self =~ Resolv::IPv4::Regex) || (self =~ Resolv::IPv6::Regex))
+    end
+  end
+end

data/lib/geocoder/kernel_logger.rb

@@ -0,0 +1,25 @@
+module Geocoder
+  class KernelLogger
+    include Singleton
+
+    def add(level, message)
+      return unless log_message_at_level?(level)
+      case level
+        when ::Logger::DEBUG, ::Logger::INFO
+          puts message
+        when ::Logger::WARN
+          warn message
+        when ::Logger::ERROR
+          raise message
+        when ::Logger::FATAL
+          fail message
+      end
+    end
+
+    private # ----------------------------------------------------------------
+
+    def log_message_at_level?(level)
+      level >= Geocoder.config.kernel_logger_level
+    end
+  end
+end

data/lib/geocoder/logger.rb

@@ -0,0 +1,47 @@
+require 'logger'
+
+module Geocoder
+
+  def self.log(level, message)
+    Logger.instance.log(level, message)
+  end
+
+  class Logger
+    include Singleton
+
+    SEVERITY = {
+      debug: ::Logger::DEBUG,
+      info: ::Logger::INFO,
+      warn: ::Logger::WARN,
+      error: ::Logger::ERROR,
+      fatal: ::Logger::FATAL
+    }
+
+    def log(level, message)
+      unless valid_level?(level)
+        raise StandardError, "Geocoder tried to log a message with an invalid log level."
+      end
+      if current_logger.respond_to? :add
+        current_logger.add(SEVERITY[level], message)
+      else
+        raise Geocoder::ConfigurationError, "Please specify valid logger for Geocoder. " +
+        "Logger specified must be :kernel or must respond to `add(level, message)`."
+      end
+      nil
+    end
+
+    private # ----------------------------------------------------------------
+
+    def current_logger
+      logger = Geocoder.config[:logger]
+      if logger == :kernel
+        logger = Geocoder::KernelLogger.instance
+      end
+      logger
+    end
+
+    def valid_level?(level)
+      SEVERITY.keys.include?(level)
+    end
+  end
+end

data/lib/geocoder/lookup.rb

@@ -1,3 +1,5 @@
+require "geocoder/lookups/test"
+
 module Geocoder
   module Lookup
     extend self
@@ -20,21 +22,32 @@ module Geocoder
     # All street address lookup services, default first.
     #
     def street_services
-      [
+      @street_services ||= [
         :dstk,
         :esri,
         :google,
         :google_premier,
-        :yahoo,
+        :google_places_details,
         :bing,
         :geocoder_ca,
         :geocoder_us,
         :yandex,
         :nominatim,
+        :mapbox,
         :mapquest,
+        :mapzen,
+        :opencagedata,
         :ovi,
+        :pelias,
+        :here,
         :baidu,
-        :test
+        :geocodio,
+        :smarty_streets,
+        :okf,
+        :postcode_anywhere_uk,
+        :geoportail_lu,
+        :test,
+        :latlon
       ]
     end
 
@@ -42,9 +55,22 @@ module Geocoder
     # All IP address lookup services, default first.
     #
     def ip_services
-      [:freegeoip, :maxmind]
+      @ip_services ||= [
+        :baidu_ip,
+        :freegeoip,
+        :geoip2,
+        :maxmind,
+        :maxmind_local,
+        :telize,
+        :pointpin,
+        :maxmind_geoip2,
+        :ipinfo_io,
+        :ipapi_com
+      ]
     end
 
+    attr_writer :street_services, :ip_services
+
     ##
     # Retrieve a Lookup object from the store.
     # Use this instead of Geocoder::Lookup::X.new to get an
@@ -64,6 +90,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(", ")
@@ -80,7 +108,3 @@ module Geocoder
     end
   end
 end
-
-Geocoder::Lookup.all_services.each do |name|
-  require "geocoder/lookups/#{name}"
-end

data/lib/geocoder/lookups/baidu.rb

@@ -13,30 +13,36 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "http://api.map.baidu.com/geocoder/v2/?" + url_query_string(query)
+      "#{protocol}://api.map.baidu.com/geocoder/v2/?" + url_query_string(query)
+    end
+
+    # HTTP only
+    def supported_protocols
+      [:http]
     end
 
     private # ---------------------------------------------------------------
 
     def results(query, reverse = false)
       return [] unless doc = fetch_data(query)
-      case doc['status']; when 0
+      case doc['status']
+      when 0
         return [doc['result']] unless doc['result'].blank?
       when 1, 3, 4
-        raise_error(Geocoder::Error, messages) ||
-          warn("Baidu Geocoding API error: server error.")
+        raise_error(Geocoder::Error, "server error.") ||
+          Geocoder.log(:warn, "Baidu Geocoding API error: server error.")
       when 2
-        raise_error(Geocoder::InvalidRequest, messages) ||
-          warn("Baidu Geocoding API error: invalid request.")
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          Geocoder.log(:warn, "Baidu Geocoding API error: invalid request.")
       when 5
-        raise_error(Geocoder::InvalidApiKey, messages) ||
-          warn("Baidu Geocoding API error: invalid api key.")
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
+          Geocoder.log(:warn, "Baidu Geocoding API error: invalid api key.")
       when 101, 102, 200..299
-        raise_error(Geocoder::RequestDenied) ||
-          warn("Baidu Geocoding API error: request denied.")
+        raise_error(Geocoder::RequestDenied, "request denied") ||
+          Geocoder.log(:warn, "Baidu Geocoding API error: request denied.")
       when 300..399
-        raise_error(Geocoder::OverQueryLimitError) ||
-          warn("Baidu Geocoding API error: over query limit.")
+        raise_error(Geocoder::OverQueryLimitError, "over query limit.") ||
+          Geocoder.log(:warn, "Baidu Geocoding API error: over query limit.")
       end
       return []
     end
@@ -51,4 +57,3 @@ module Geocoder::Lookup
 
   end
 end
-