geocoder 1.1.4 → 1.1.8

data/lib/geocoder/lookups/esri.rb

@@ -0,0 +1,48 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/esri"
+
+module Geocoder::Lookup
+  class Esri < Base
+    
+    def name
+      "Esri"
+    end
+
+    def query_url(query)
+      search_keyword = query.reverse_geocode? ? "reverseGeocode" : "find"
+
+      "#{protocol}://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/#{search_keyword}?" +
+        url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if (!query.reverse_geocode?)
+        return [] if doc['locations'].empty?
+      end
+
+      if (doc['error'].nil?)
+        return [ doc ]
+      else
+        return []
+      end
+    end
+
+    def query_url_params(query)
+      params = {
+        :f => "pjson",
+        :outFields => "*"
+      }
+      if query.reverse_geocode?
+        params[:location] = query.coordinates.reverse.join(',')
+      else
+        params[:text] = query.sanitized_text
+      end
+      params.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)
-      "http://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)
-      "http://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

@@ -1,15 +1,43 @@
+require 'cgi'
 require 'geocoder/lookups/base'
-require "geocoder/lookups/nominatim"
 require "geocoder/results/mapquest"
 
 module Geocoder::Lookup
-  class Mapquest < Nominatim
+  class Mapquest < Base
 
-    private # ---------------------------------------------------------------
+    def name
+      "Mapquest"
+    end
+
+    def required_api_key_parts
+      []
+    end
 
     def query_url(query)
-      method = query.reverse_geocode? ? "reverse" : "search"
-      "http://open.mapquestapi.com/#{method}?" + url_query_string(query)
+      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)
+      params = { :location => query.sanitized_text }
+      if key = configuration.api_key
+        params[:key] = CGI.unescape(key)
+      end
+      params.merge(super)
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      doc["results"][0]['locations']
+    end
+
   end
 end

data/lib/geocoder/lookups/maxmind.rb

@@ -0,0 +1,88 @@
+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 # ---------------------------------------------------------------
+
+    ##
+    # Return the name of the configured service, or raise an exception.
+    #
+    def configured_service!
+      if s = configuration[:service] and services.keys.include?(s)
+        return 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
+
+    def service_code
+      services[configured_service!]
+    end
+
+    def service_response_fields_count
+      Geocoder::Result::Maxmind.field_names[configured_service!].size
+    end
+
+    def data_contains_error?(parsed_data)
+      # if all fields given then there is an error
+      parsed_data.size == service_response_fields_count and !parsed_data.last.nil?
+    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 !data_contains_error?(doc)
+          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"
-      "http://nominatim.openstreetmap.org/#{method}?" + url_query_string(query)
-    end
   end
 end

data/lib/geocoder/lookups/ovi.rb

@@ -0,0 +1,52 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/ovi'
+
+module Geocoder::Lookup
+  class Ovi < Base
+
+    def name
+      "Ovi"
+    end
+
+    def required_api_key_parts
+      []
+    end
+
+    def query_url(query)
+      "#{protocol}://lbs.ovi.com/search/6.2/geocode.json?" + url_query_string(query)
+    end
+
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return [] unless doc['Response'] && doc['Response']['View']
+      if r=doc['Response']['View']
+        return [] if r.nil? || !r.is_a?(Array) || r.empty?
+        return r.first['Result']
+      end
+      []
+    end
+
+    def query_url_params(query)
+      super.merge(
+        :searchtext=>query.sanitized_text,
+        :gen=>1,
+        :app_id=>api_key,
+        :app_code=>api_code
+      )
+    end
+
+    def api_key
+      if a=configuration.api_key
+        return a.first if a.is_a?(Array)
+      end
+    end
+
+    def api_code
+      if a=configuration.api_key
+        return a.last if a.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/test.rb

@@ -5,12 +5,21 @@ module Geocoder
   module Lookup
     class Test < Base
 
+      def name
+        "Test"
+      end
+
       def self.add_stub(query_text, results)
         stubs[query_text] = results
       end
 
+      def self.set_default_stub(results)
+        @default_stub = results
+      end
+
       def self.read_stub(query_text)
         stubs.fetch(query_text) {
+          return @default_stub unless @default_stub.nil?
           raise ArgumentError, "unknown stub request #{query_text}"
         }
       end
@@ -21,6 +30,7 @@ module Geocoder
 
       def self.reset
         @stubs = {}
+        @default_stub = nil
       end
 
       private

data/lib/geocoder/lookups/yahoo.rb

@@ -1,73 +1,86 @@
 require 'geocoder/lookups/base'
 require "geocoder/results/yahoo"
+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
 
-    private # ---------------------------------------------------------------
-
-    def results(query)
-      return [] unless doc = fetch_data(query)
-      doc = doc['ResultSet']
-      if api_version(doc).to_i == 1
-        return version_1_results(doc)
-      elsif api_version(doc).to_i == 2
-        return version_2_results(doc)
-      else
-        warn "Yahoo Geocoding API error: #{doc['Error']} (#{doc['ErrorMessage']})."
-        return []
-      end
+    def required_api_key_parts
+      ["consumer key", "consumer secret"]
     end
 
-    def api_version(doc)
-      if doc.include?('version')
-        return doc['version'].to_f
-      elsif doc.include?('@version')
-        return doc['@version'].to_f
-      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
 
-    def version_1_results(doc)
-      if doc['Error'] == 0
-        if doc['Found'] > 0
-          return doc['Results']
+    private # ---------------------------------------------------------------
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      doc = doc['bossresponse']
+      if doc['responsecode'].to_i == 200
+        if doc['placefinder']['count'].to_i > 0
+          return doc['placefinder']['results']
         else
           return []
         end
+      else
+        warn "Yahoo Geocoding API error: #{doc['responsecode']} (#{doc['reason']})."
+        return []
       end
     end
 
     ##
-    # Return array of results, or nil if an error.
+    # Yahoo returns errors as XML even when JSON format is specified.
+    # Handle that here, without parsing the XML
+    # (which would add unnecessary complexity).
+    # Yahoo auth errors can also be cryptic, so add raw error desc
+    # to warning message.
     #
-    def version_2_results(doc)
-      # seems to have Error == 7 when no results, though this is not documented
-      if [0, 7].include?(doc['Error'].to_i)
-        if doc['Found'].to_i > 0
-          r = doc['Result']
-          return r.is_a?(Array) ? r : [r]
-        else
-          return []
+    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 =~ /<yahoo:description>(Please provide valid credentials.*)<\/yahoo:description>/i
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid API key. Error response: #{$1}")
         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?}",
-        :locale => "#{Geocoder::Configuration.language}_US",
-        :appid => Geocoder::Configuration.api_key
-      )
+        :locale => "#{configuration.language}_US",
+        :appid => configuration.api_key
+      }.merge(super)
     end
 
-    def query_url(query)
-      "http://where.yahooapis.com/geocode?" + url_query_string(query)
+    def cache_key(query)
+      raw_url(query)
+    end
+
+    def base_url
+      "#{protocol}://yboss.yahooapis.com/geo/placefinder?"
+    end
+
+    def raw_url(query)
+      base_url + url_query_string(query)
     end
   end
 end

data/lib/geocoder/lookups/yandex.rb

@@ -4,16 +4,28 @@ require "geocoder/results/yandex"
 module Geocoder::Lookup
   class Yandex < Base
 
+    def name
+      "Yandex"
+    end
+
     def map_link_url(coordinates)
       "http://maps.yandex.ru/?ll=#{coordinates.reverse.join(',')}"
     end
 
+    def query_url(query)
+      "#{protocol}://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
+    end
+
     private # ---------------------------------------------------------------
 
     def results(query)
       return [] unless doc = fetch_data(query)
       if err = doc['error']
-        warn "Yandex Geocoding API error: #{err['status']} (#{err['message']})."
+        if err["status"] == 401 and err["message"] == "invalid key"
+          raise_error(Geocoder::InvalidApiKey) || warn("Invalid API key.")
+        else
+          warn "Yandex Geocoding API error: #{err['status']} (#{err['message']})."
+        end
         return []
       end
       if doc = doc['response']['GeoObjectCollection']
@@ -31,16 +43,12 @@ module Geocoder::Lookup
       else
         q = query.sanitized_text
       end
-      super.merge(
+      {
         :geocode => q,
         :format => "json",
-        :plng => "#{Geocoder::Configuration.language}", # supports ru, uk, be
-        :key => Geocoder::Configuration.api_key
-      )
-    end
-
-    def query_url(query)
-      "http://geocode-maps.yandex.ru/1.x/?" + url_query_string(query)
+        :plng => "#{configuration.language}", # supports ru, uk, be
+        :key => configuration.api_key
+      }.merge(super)
     end
   end
 end

data/lib/geocoder/models/mongoid.rb

@@ -18,7 +18,7 @@ module Geocoder
         super(options)
         if options[:skip_index] == false
           # create 2d index
-          if (::Mongoid::VERSION >= "3")
+          if defined?(::Mongoid::VERSION) && ::Mongoid::VERSION >= "3"
             index({ geocoder_options[:coordinates].to_sym => '2d' }, 
                   {:min => -180, :max => 180})
           else