geocoder 1.1.5 → 1.1.6

data/lib/geocoder/lookups/bing.rb

@@ -4,34 +4,44 @@ require "geocoder/results/bing"
 module Geocoder::Lookup
   class Bing < Base
 
+    def name
+      "Bing"
+    end
+
     def map_link_url(coordinates)
       "http://www.bing.com/maps/default.aspx?cp=#{coordinates.join('~')}"
     end
 
+    def required_api_key_parts
+      ["key"]
+    end
+
+    def query_url(query)
+      "#{protocol}://dev.virtualearth.net/REST/v1/Locations" +
+        (query.reverse_geocode? ? "/#{query.sanitized_text}?" : "?") +
+        url_query_string(query)
+    end
+
     private # ---------------------------------------------------------------
 
     def results(query)
       return [] unless doc = fetch_data(query)
 
-      if doc['statusDescription'] == "OK"
+      if doc['statusCode'] == 200
         return doc['resourceSets'].first['estimatedTotal'] > 0 ? doc['resourceSets'].first['resources'] : []
+      elsif doc['statusCode'] == 401 and doc["authenticationResultCode"] == "InvalidCredentials"
+        raise_error(Geocoder::InvalidApiKey) || warn("Invalid Bing API key.")
       else
         warn "Bing Geocoding API error: #{doc['statusCode']} (#{doc['statusDescription']})."
-        return []
       end
+      return []
     end
 
     def query_url_params(query)
-      super.merge(
-        :key => Geocoder::Configuration.api_key,
+      {
+        :key => configuration.api_key,
         :query => query.reverse_geocode? ? nil : query.sanitized_text
-      )
-    end
-
-    def query_url(query)
-      "#{protocol}://dev.virtualearth.net/REST/v1/Locations" +
-        (query.reverse_geocode? ? "/#{query.sanitized_text}?" : "?") +
-        url_query_string(query)
+      }.merge(super)
     end
   end
 end

data/lib/geocoder/lookups/freegeoip.rb

@@ -4,6 +4,14 @@ require 'geocoder/results/freegeoip'
 module Geocoder::Lookup
   class Freegeoip < Base
 
+    def name
+      "FreeGeoIP"
+    end
+
+    def query_url(query)
+      "#{protocol}://freegeoip.net/json/#{query.sanitized_text}"
+    end
+
     private # ---------------------------------------------------------------
 
     def parse_raw_data(raw_data)
@@ -35,9 +43,5 @@ module Geocoder::Lookup
         "country_code" => "RD"
       }
     end
-
-    def query_url(query)
-      "#{protocol}://freegeoip.net/json/#{query.sanitized_text}"
-    end
   end
 end

data/lib/geocoder/lookups/geocoder_ca.rb

@@ -4,6 +4,14 @@ require "geocoder/results/geocoder_ca"
 module Geocoder::Lookup
   class GeocoderCa < Base
 
+    def name
+      "Geocoder.ca"
+    end
+
+    def query_url(query)
+      "#{protocol}://geocoder.ca/?" + url_query_string(query)
+    end
+
     private # ---------------------------------------------------------------
 
     def results(query)
@@ -19,12 +27,12 @@ module Geocoder::Lookup
     end
 
     def query_url_params(query)
-      params = super.merge(
+      params = {
         :geoit    => "xml",
         :jsonp    => 1,
         :callback => "test",
-        :auth     => Geocoder::Configuration.api_key
-      )
+        :auth     => configuration.api_key
+      }.merge(super)
       if query.reverse_geocode?
         lat,lon = query.coordinates
         params[:latt] = lat
@@ -38,10 +46,6 @@ module Geocoder::Lookup
       params
     end
 
-    def query_url(query)
-      "#{protocol}://geocoder.ca/?" + url_query_string(query)
-    end
-
     def parse_raw_data(raw_data)
       super raw_data[/^test\((.*)\)\;\s*$/, 1]
     end

data/lib/geocoder/lookups/google.rb

@@ -4,10 +4,18 @@ require "geocoder/results/google"
 module Geocoder::Lookup
   class Google < Base
 
+    def name
+      "Google"
+    end
+
     def map_link_url(coordinates)
       "http://maps.google.com/maps?q=#{coordinates.join(',')}"
     end
 
+    def query_url(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
+    end
+
     private # ---------------------------------------------------------------
 
     def results(query)
@@ -31,23 +39,24 @@ module Geocoder::Lookup
       params = {
         (query.reverse_geocode? ? :latlng : :address) => query.sanitized_text,
         :sensor => "false",
-        :language => Geocoder::Configuration.language
+        :language => configuration.language
       }
       unless (bounds = query.options[:bounds]).nil?
         params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join('|')
       end
+      unless (region = query.options[:region]).nil?
+        params[:region] = region
+      end
+      unless (components = query.options[:components]).nil?
+        params[:components] = components.is_a?(Array) ? components.join("|") : components
+      end
       params
     end
 
     def query_url_params(query)
-      super.merge(query_url_google_params(query)).merge(
-        :key => Geocoder::Configuration.api_key
-      )
-    end
-
-    def query_url(query)
-      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?" + url_query_string(query)
+      query_url_google_params(query).merge(
+        :key => configuration.api_key
+      ).merge(super)
     end
   end
 end
-

data/lib/geocoder/lookups/google_premier.rb

@@ -6,14 +6,12 @@ require 'geocoder/results/google_premier'
 module Geocoder::Lookup
   class GooglePremier < Google
 
-    private # ---------------------------------------------------------------
+    def name
+      "Google Premier"
+    end
 
-    def query_url_params(query)
-      super.merge(query_url_google_params(query)).merge(
-        :key => nil, # don't use param inherited from Google lookup
-        :client => Geocoder::Configuration.api_key[1],
-        :channel => Geocoder::Configuration.api_key[2]
-      )
+    def required_api_key_parts
+      ["private key", "client", "channel"]
     end
 
     def query_url(query)
@@ -21,8 +19,18 @@ module Geocoder::Lookup
       "#{protocol}://maps.googleapis.com#{path}&signature=#{sign(path)}"
     end
 
+    private # ---------------------------------------------------------------
+
+    def query_url_params(query)
+      query_url_google_params(query).merge(super).merge(
+        :key => nil, # don't use param inherited from Google lookup
+        :client => configuration.api_key[1],
+        :channel => configuration.api_key[2]
+      )
+    end
+
     def sign(string)
-      raw_private_key = url_safe_base64_decode(Geocoder::Configuration.api_key[0])
+      raw_private_key = url_safe_base64_decode(configuration.api_key[0])
       digest = OpenSSL::Digest::Digest.new('sha1')
       raw_signature = OpenSSL::HMAC.digest(digest, raw_private_key, string)
       url_safe_base64_encode(raw_signature)

data/lib/geocoder/lookups/mapquest.rb

@@ -5,26 +5,33 @@ require "geocoder/results/mapquest"
 module Geocoder::Lookup
   class Mapquest < Base
 
-    private # ---------------------------------------------------------------
+    def name
+      "Mapquest"
+    end
+
+    def required_api_key_parts
+      ["key"]
+    end
 
     def query_url(query)
-      key = Geocoder::Configuration.api_key
+      key = configuration.api_key
       domain = key ? "www" : "open"
       url = "#{protocol}://#{domain}.mapquestapi.com/geocoding/v1/#{search_type(query)}?"
       url + url_query_string(query)
     end
 
+    private # ---------------------------------------------------------------
+
     def search_type(query)
       query.reverse_geocode? ? "reverse" : "address"
     end
 
     def query_url_params(query)
-      key = Geocoder::Configuration.api_key
       params = { :location => query.sanitized_text }
-      if key
+      if key = configuration.api_key
         params[:key] = CGI.unescape(key)
       end
-      super.merge(params)
+      params.merge(super)
     end
 
     def results(query)

data/lib/geocoder/lookups/maxmind.rb

@@ -0,0 +1,72 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/maxmind'
+require 'csv'
+
+module Geocoder::Lookup
+  class Maxmind < Base
+
+    def name
+      "MaxMind"
+    end
+
+    def query_url(query)
+      "#{protocol}://geoip.maxmind.com/#{service_code}?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def service_code
+      if s = configuration[:service] and services.keys.include?(s)
+        services[s]
+      else
+        raise(
+          Geocoder::ConfigurationError,
+          "When using MaxMind you MUST specify a service name: " +
+          "Geocoder.configure(:maxmind => {:service => ...}), " +
+          "where '...' is one of: #{services.keys.inspect}"
+        )
+      end
+    end
+
+    ##
+    # Service names mapped to code used in URL.
+    #
+    def services
+      {
+        :country => "a",
+        :city => "b",
+        :city_isp_org => "f",
+        :omni => "e"
+      }
+    end
+
+    def results(query)
+      # don't look up a loopback address, just return the stored result
+      return [reserved_result] if query.loopback_ip_address?
+      doc = fetch_data(query)
+      if doc and doc.is_a?(Array)
+        if doc.last.nil?
+          return [doc]
+        elsif doc.last == "INVALID_LICENSE_KEY"
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid MaxMind API key.")
+        end
+      end
+      return []
+    end
+
+    def parse_raw_data(raw_data)
+      CSV.parse_line raw_data
+    end
+
+    def reserved_result
+      ",,,,0,0,0,0,,,"
+    end
+
+    def query_url_params(query)
+      {
+        :l => configuration.api_key,
+        :i => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end

data/lib/geocoder/lookups/nominatim.rb

@@ -4,10 +4,20 @@ require "geocoder/results/nominatim"
 module Geocoder::Lookup
   class Nominatim < Base
 
+    def name
+      "Nominatim"
+    end
+
     def map_link_url(coordinates)
       "http://www.openstreetmap.org/?lat=#{coordinates[0]}&lon=#{coordinates[1]}&zoom=15&layers=M"
     end
 
+    def query_url(query)
+      method = query.reverse_geocode? ? "reverse" : "search"
+      host = configuration[:host] || "nominatim.openstreetmap.org"
+      "#{protocol}://#{host}/#{method}?" + url_query_string(query)
+    end
+
     private # ---------------------------------------------------------------
 
     def results(query)
@@ -16,12 +26,12 @@ module Geocoder::Lookup
     end
 
     def query_url_params(query)
-      params = super.merge(
+      params = {
         :format => "json",
         :polygon => "1",
         :addressdetails => "1",
-        :"accept-language" => Geocoder::Configuration.language
-      )
+        :"accept-language" => configuration.language
+      }.merge(super)
       if query.reverse_geocode?
         lat,lon = query.coordinates
         params[:lat] = lat
@@ -31,10 +41,5 @@ module Geocoder::Lookup
       end
       params
     end
-
-    def query_url(query)
-      method = query.reverse_geocode? ? "reverse" : "search"
-      "#{protocol}://nominatim.openstreetmap.org/#{method}?" + url_query_string(query)
-    end
   end
 end

data/lib/geocoder/lookups/test.rb

@@ -5,6 +5,10 @@ module Geocoder
   module Lookup
     class Test < Base
 
+      def name
+        "Test"
+      end
+
       def self.add_stub(query_text, results)
         stubs[query_text] = results
       end

data/lib/geocoder/lookups/yahoo.rb

@@ -5,10 +5,26 @@ require 'oauth_util'
 module Geocoder::Lookup
   class Yahoo < Base
 
+    def name
+      "Yahoo BOSS"
+    end
+
     def map_link_url(coordinates)
       "http://maps.yahoo.com/#lat=#{coordinates[0]}&lon=#{coordinates[1]}"
     end
 
+    def required_api_key_parts
+      ["consumer key", "consumer secret"]
+    end
+
+    def query_url(query)
+      parsed_url = URI.parse(raw_url(query))
+      o = OauthUtil.new
+      o.consumer_key = configuration.api_key[0]
+      o.consumer_secret = configuration.api_key[1]
+      base_url + o.sign(parsed_url).query_string
+    end
+
     private # ---------------------------------------------------------------
 
     def results(query)
@@ -26,12 +42,31 @@ module Geocoder::Lookup
       end
     end
 
+    ##
+    # Yahoo returns errors as XML even when JSON format is specified.
+    # Handle that here, without parsing the XML
+    # (which would add unnecessary complexity).
+    #
+    def parse_raw_data(raw_data)
+      if raw_data.match /^<\?xml/
+        if raw_data.include?("Rate Limit Exceeded")
+          raise_error(Geocoder::OverQueryLimitError) || warn("Over API query limit.")
+        elsif raw_data.include?("Please provide valid credentials")
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid API key.")
+        end
+      else
+        super(raw_data)
+      end
+    end
+
     def query_url_params(query)
-      super.merge(
+      {
         :location => query.sanitized_text,
         :flags => "JXTSR",
-        :gflags => "AC#{'R' if query.reverse_geocode?}"
-      )
+        :gflags => "AC#{'R' if query.reverse_geocode?}",
+        :locale => "#{configuration.language}_US",
+        :appid => configuration.api_key
+      }.merge(super)
     end
 
     def cache_key(query)
@@ -45,13 +80,5 @@ module Geocoder::Lookup
     def raw_url(query)
       base_url + url_query_string(query)
     end
-
-    def query_url(query)
-      parsed_url = URI.parse(raw_url(query))
-      o = OauthUtil.new
-      o.consumer_key = Geocoder::Configuration.api_key[0]
-      o.consumer_secret = Geocoder::Configuration.api_key[1]
-      base_url + o.sign(parsed_url).query_string
-    end
   end
 end