geocoder 1.1.9 → 1.2.0

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.rb

@@ -5,17 +5,17 @@ require "geocoder/exceptions"
 require "geocoder/cache"
 require "geocoder/request"
 require "geocoder/lookup"
+require "geocoder/ip_address"
 require "geocoder/models/active_record" if defined?(::ActiveRecord)
 require "geocoder/models/mongoid" if defined?(::Mongoid)
 require "geocoder/models/mongo_mapper" if defined?(::MongoMapper)
 
 module Geocoder
-  extend self
 
   ##
   # Search for information about an address or a set of coordinates.
   #
-  def search(query, options = {})
+  def self.search(query, options = {})
     query = Geocoder::Query.new(query, options) unless query.is_a?(Geocoder::Query)
     query.blank? ? [] : query.execute
   end
@@ -23,7 +23,7 @@ module Geocoder
   ##
   # Look up the coordinates of the given street or IP address.
   #
-  def coordinates(address, options = {})
+  def self.coordinates(address, options = {})
     if (results = search(address, options)).size > 0
       results.first.coordinates
     end
@@ -33,19 +33,11 @@ module Geocoder
   # Look up the address of the given coordinates ([lat,lon])
   # or IP address (string).
   #
-  def address(query, options = {})
+  def self.address(query, options = {})
     if (results = search(query, options)).size > 0
       results.first.address
     end
   end
-
-  ##
-  # The working Cache object, or +nil+ if none configured.
-  #
-  def cache
-    warn "WARNING: Calling Geocoder.cache is DEPRECATED. The #cache method now belongs to the Geocoder::Lookup object."
-    Geocoder::Lookup.get(Geocoder.config.lookup).cache
-  end
 end
 
 # load Railtie if Rails exists

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
 
@@ -254,6 +259,40 @@ module Geocoder
       [center[0] + delta_lat, center[1] + delta_long]
     end
 
+    ##
+    # Given a start point, distance, and heading (in degrees), 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
 

data/lib/geocoder/ip_address.rb

@@ -0,0 +1,12 @@
+module Geocoder
+  class IpAddress < String
+
+    def loopback?
+      valid? and (self == "0.0.0.0" or self.match(/\A127\./))
+    end
+
+    def valid?
+      !!self.match(/\A(::ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\z/)
+    end
+  end
+end

data/lib/geocoder/lookup.rb

@@ -33,7 +33,11 @@ module Geocoder
         :nominatim,
         :mapquest,
         :ovi,
+        :here,
         :baidu,
+        :cloudmade,
+        :geocodio,
+        :smarty_streets,
         :test
       ]
     end
@@ -42,7 +46,12 @@ module Geocoder
     # All IP address lookup services, default first.
     #
     def ip_services
-      [:freegeoip, :maxmind]
+      [
+        :freegeoip,
+        :maxmind,
+        :maxmind_local,
+        :baidu_ip
+      ]
     end
 
     ##

data/lib/geocoder/lookups/baidu.rb

@@ -20,22 +20,23 @@ module Geocoder::Lookup
 
     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) ||
+        raise_error(Geocoder::Error, "server error.") ||
           warn("Baidu Geocoding API error: server error.")
       when 2
-        raise_error(Geocoder::InvalidRequest, messages) ||
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
           warn("Baidu Geocoding API error: invalid request.")
       when 5
-        raise_error(Geocoder::InvalidApiKey, messages) ||
+        raise_error(Geocoder::InvalidApiKey, "invalid api key") ||
           warn("Baidu Geocoding API error: invalid api key.")
       when 101, 102, 200..299
-        raise_error(Geocoder::RequestDenied) ||
+        raise_error(Geocoder::RequestDenied, "request denied") ||
           warn("Baidu Geocoding API error: request denied.")
       when 300..399
-        raise_error(Geocoder::OverQueryLimitError) ||
+        raise_error(Geocoder::OverQueryLimitError, "over query limit.") ||
           warn("Baidu Geocoding API error: over query limit.")
       end
       return []

data/lib/geocoder/lookups/baidu_ip.rb

@@ -0,0 +1,54 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/baidu_ip'
+
+module Geocoder::Lookup
+  class BaiduIp < Base
+
+    def name
+      "Baidu IP"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "http://api.map.baidu.com/location/ip?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when 0
+        return [doc['content']] unless doc['content'].blank?
+      when 1, 3, 4
+        raise_error(Geocoder::Error, "server error.") ||
+          warn("Baidu IP Geocoding API error: server error.")
+      when 2
+        raise_error(Geocoder::InvalidRequest, "invalid request.") ||
+          warn("Baidu IP Geocoding API error: invalid request.")
+      when 5
+        raise_error(Geocoder::InvalidApiKey, "invalid api key.") ||
+          warn("Baidu IP Geocoding API error: invalid api key.")
+      when 101, 102, 200..299
+        raise_error(Geocoder::RequestDenied, "request denied.") ||
+          warn("Baidu IP Geocoding API error: request denied.")
+      when 300..399
+        raise_error(Geocoder::OverQueryLimitError, "over query limit") ||
+          warn("Baidu IP Geocoding API error: over query limit.")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      {
+        :ip => query.sanitized_text,
+        :ak => configuration.api_key,
+        :coor => "bd09ll"
+      }.merge(super)
+    end
+
+  end
+end

data/lib/geocoder/lookups/base.rb

@@ -15,6 +15,9 @@ module Geocoder
   module Lookup
 
     class Base
+      def initialize
+        @cache = nil
+      end
 
       ##
       # Human-readable name of the geocoding API.
@@ -211,7 +214,21 @@ module Geocoder
         else
           check_api_key_configuration!(query)
           response = make_api_request(query)
+          check_response_for_errors!(response)
           body = response.body
+
+          # apply the charset from the Content-Type header, if possible
+          ct = response['content-type']
+
+          if ct && ct['charset']
+            charset = ct.split(';').select do |s|
+              s['charset']
+            end.first.to_s.split('=')
+            if charset.length == 2
+              body.force_encoding(charset.last) rescue ArgumentError
+            end
+          end
+
           if cache and valid_response?(response)
             cache[key] = body
           end
@@ -220,6 +237,19 @@ module Geocoder
         body
       end
 
+      def check_response_for_errors!(response)
+        if response.code.to_i == 400
+          raise_error(Geocoder::InvalidRequest) ||
+            warn("Geocoding API error: 400 Bad Request")
+        elsif response.code.to_i == 401
+          raise_error(Geocoder::RequestDenied) ||
+            warn("Geocoding API error: 401 Unauthorized")
+        elsif response.code.to_i == 402
+          raise_error(Geocoder::OverQueryLimitError) ||
+            warn("Geocoding API error: 402 Payment Required")
+        end
+      end
+
       ##
       # Make an HTTP(S) request to a geocoding API and
       # return the response object.
@@ -227,15 +257,13 @@ module Geocoder
       def make_api_request(query)
         timeout(configuration.timeout) do
           uri = URI.parse(query_url(query))
-          # client = http_client.new(uri.host, uri.port)
-          # client.use_ssl = true if configuration.use_https
-          # client.get(uri.request_uri, configuration.http_headers)
-
-          http_client.start(uri.host, uri.port) do |client|
-            client.use_ssl = true if configuration.use_https
-            req = Net::HTTP::Get.new(uri.request_uri, configuration.http_headers)
-            req.basic_auth(uri.user, uri.password) if uri.user and uri.password
-            client.request(req)
+          args = [uri.host, uri.port]
+          args = args.push(uri.user, uri.password) unless uri.user.nil? or uri.password.nil?
+          opts = {}
+          opts[:use_ssl] = true if configuration.use_https
+
+          http_client.start(*args, opts) do |client|
+            client.get(uri.request_uri, configuration.http_headers)
           end
         end
       end

data/lib/geocoder/lookups/bing.rb

@@ -17,13 +17,19 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{protocol}://dev.virtualearth.net/REST/v1/Locations" +
-        (query.reverse_geocode? ? "/#{query.sanitized_text}?" : "?") +
-        url_query_string(query)
+      base_url(query) + url_query_string(query)
     end
 
     private # ---------------------------------------------------------------
 
+    def base_url(query)
+      url = "#{protocol}://dev.virtualearth.net/REST/v1/Locations"
+      if !query.reverse_geocode? and r = query.options[:region]
+        url << "/#{r}"
+      end
+      url + "/" + URI.escape(query.sanitized_text.strip) + "?"
+    end
+
     def results(query)
       return [] unless doc = fetch_data(query)
 
@@ -39,8 +45,7 @@ module Geocoder::Lookup
 
     def query_url_params(query)
       {
-        :key => configuration.api_key,
-        :query => query.reverse_geocode? ? nil : query.sanitized_text
+        key: configuration.api_key
       }.merge(super)
     end
   end

data/lib/geocoder/lookups/cloudmade.rb

@@ -0,0 +1,35 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/cloudmade'
+
+module Geocoder::Lookup
+  class Cloudmade < Base
+
+    def name
+      "Cloudmade"
+    end
+
+    def query_url(query)
+      "http://geocoding.cloudmade.com/#{configuration.api_key}/geocoding/v2/find.js?#{url_query_string(query)}"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
+
+    private
+
+    def results(query)
+      data = fetch_data(query)
+      (data && data['features']) || []
+    end
+
+    def query_url_params(query)
+      {
+        :query => query.sanitized_text,
+        :return_location => true,
+        :return_geometry => false
+      }.merge(super)
+    end
+
+  end
+end

data/lib/geocoder/lookups/freegeoip.rb

@@ -9,7 +9,7 @@ module Geocoder::Lookup
     end
 
     def query_url(query)
-      "#{protocol}://freegeoip.net/json/#{query.sanitized_text}"
+      "#{protocol}://#{host}/json/#{query.sanitized_text}"
     end
 
     private # ---------------------------------------------------------------
@@ -39,5 +39,9 @@ module Geocoder::Lookup
         "country_code" => "RD"
       }
     end
+
+    def host
+      configuration[:host] || "freegeoip.net"
+    end
   end
 end

data/lib/geocoder/lookups/geocodio.rb

@@ -0,0 +1,42 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocodio"
+
+module Geocoder::Lookup
+  class Geocodio < Base
+
+    def name
+      "Geocodio"
+    end
+
+    def query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1/#{path}?#{url_query_string(query)}"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc["results"] if doc['error'].nil?
+      
+      if doc['error'] == 'Invalid API key'
+        raise_error(Geocoder::InvalidApiKey) ||
+          warn("Geocodio service error: invalid API key.")
+      elsif doc['error'].match(/You have reached your daily maximum/)
+        raise_error(Geocoder::OverQueryLimitError, doc['error']) ||
+          warn("Geocodio service error: #{doc['error']}.")
+      else
+        raise_error(Geocoder::InvalidRequest, doc['error']) ||
+          warn("Geocodio service error: #{doc['error']}.")
+      end
+      []
+    end
+
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      {
+        :api_key => configuration.api_key,
+        :q => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end