geocoder 1.1.3 → 1.1.6

data/lib/geocoder/lookups/test.rb

@@ -5,12 +5,18 @@ module Geocoder
   module Lookup
     class Test < Base
 
-      def self.add_stub(query, results)
-        stubs[query] = results
+      def name
+        "Test"
       end
 
-      def self.read_stub(query)
-        stubs.fetch(query) { raise ArgumentError, "unknown stub request #{query}" }
+      def self.add_stub(query_text, results)
+        stubs[query_text] = results
+      end
+
+      def self.read_stub(query_text)
+        stubs.fetch(query_text) {
+          raise ArgumentError, "unknown stub request #{query_text}"
+        }
       end
 
       def self.stubs
@@ -23,8 +29,8 @@ module Geocoder
 
       private
 
-      def results(query, reverse = false)
-        Geocoder::Lookup::Test.read_stub(query)
+      def results(query)
+        Geocoder::Lookup::Test.read_stub(query.text)
       end
 
     end

data/lib/geocoder/lookups/yahoo.rb

@@ -1,34 +1,84 @@
 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
 
+    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, reverse = false)
-      return [] unless doc = fetch_data(query, reverse)
-      if doc = doc['ResultSet'] and doc['Error'] == 0
-        return doc['Found'] > 0 ? doc['Results'] : []
+    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['Error']} (#{doc['ErrorMessage']})."
+        warn "Yahoo Geocoding API error: #{doc['responsecode']} (#{doc['reason']})."
         return []
       end
     end
 
-    def query_url(query, reverse = false)
-      params = {
-        :location => query,
+    ##
+    # 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)
+      {
+        :location => query.sanitized_text,
         :flags => "JXTSR",
-        :gflags => "AC#{'R' if reverse}",
-        :locale => "#{Geocoder::Configuration.language}_US",
-        :appid => Geocoder::Configuration.api_key
-      }
-      "http://where.yahooapis.com/geocode?" + hash_to_query(params)
+        :gflags => "AC#{'R' if query.reverse_geocode?}",
+        :locale => "#{configuration.language}_US",
+        :appid => configuration.api_key
+      }.merge(super)
+    end
+
+    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, reverse = false)
-      return [] unless doc = fetch_data(query, reverse)
+    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']
@@ -25,15 +37,18 @@ module Geocoder::Lookup
       end
     end
 
-    def query_url(query, reverse = false)
-      query = query.split(",").reverse.join(",") if reverse
-      params = {
-        :geocode => query,
+    def query_url_params(query)
+      if query.reverse_geocode?
+        q = query.coordinates.reverse.join(",")
+      else
+        q = query.sanitized_text
+      end
+      {
+        :geocode => q,
         :format => "json",
-        :plng => "#{Geocoder::Configuration.language}", # supports ru, uk, be
-        :key => Geocoder::Configuration.api_key
-      }
-      "http://geocode-maps.yandex.ru/1.x/?" + hash_to_query(params)
+        :plng => "#{configuration.language}", # supports ru, uk, be
+        :key => configuration.api_key
+      }.merge(super)
     end
   end
 end

data/lib/geocoder/models/mongoid.rb

@@ -1,4 +1,3 @@
-require 'mongoid/version'
 require 'geocoder/models/base'
 require 'geocoder/models/mongo_base'
 
@@ -19,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

data/lib/geocoder/query.rb

@@ -0,0 +1,103 @@
+module Geocoder
+  class Query
+    attr_accessor :text, :options
+
+    def initialize(text, options = {})
+      self.text = text
+      self.options = options
+    end
+
+    def execute
+      lookup.search(text, options)
+    end
+
+    def to_s
+      text
+    end
+
+    def sanitized_text
+      if coordinates?
+        text.split(/\s*,\s*/).join(',')
+      else
+        text
+      end
+    end
+
+    ##
+    # Get a Lookup object (which communicates with the remote geocoding API)
+    # appropriate to the Query text.
+    #
+    def lookup
+      if ip_address?
+        name = Configuration.ip_lookup || Geocoder::Lookup.ip_services.first
+      else
+        name = Configuration.lookup || Geocoder::Lookup.street_services.first
+      end
+      Lookup.get(name)
+    end
+
+    def url
+      lookup.query_url(self)
+    end
+
+    ##
+    # Is the Query blank? (ie, should we not bother searching?)
+    # A query is considered blank if its text is nil or empty string AND
+    # no URL parameters are specified.
+    #
+    def blank?
+      !params_given? and (
+        (text.is_a?(Array) and text.compact.size < 2) or
+        text.to_s.match(/^\s*$/)
+      )
+    end
+
+    ##
+    # Does the Query text look like an IP address?
+    #
+    # Does not check for actual validity, just the appearance of four
+    # dot-delimited numbers.
+    #
+    def ip_address?
+      !!text.to_s.match(/^(::ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+    end
+
+    ##
+    # Is the Query text a loopback IP address?
+    #
+    def loopback_ip_address?
+      !!(text == "0.0.0.0" or text.to_s.match(/^127/))
+    end
+
+    ##
+    # Does the given string look like latitude/longitude coordinates?
+    #
+    def coordinates?
+      text.is_a?(Array) or (
+        text.is_a?(String) and
+        !!text.to_s.match(/^-?[0-9\.]+, *-?[0-9\.]+$/)
+      )
+    end
+
+    ##
+    # Return the latitude/longitude coordinates specified in the query,
+    # or nil if none.
+    #
+    def coordinates
+      sanitized_text.split(',') if coordinates?
+    end
+
+    ##
+    # Should reverse geocoding be performed for this query?
+    #
+    def reverse_geocode?
+      coordinates?
+    end
+
+    private # ----------------------------------------------------------------
+
+    def params_given?
+      !!(options[:params].is_a?(Hash) and options[:params].keys.size > 0)
+    end
+  end
+end

data/lib/geocoder/request.rb

@@ -5,7 +5,13 @@ module Geocoder
 
     def location
       unless defined?(@location)
-        @location = Geocoder.search(ip).first
+        if env.has_key?('HTTP_X_REAL_IP')
+          @location = Geocoder.search(env['HTTP_X_REAL_IP']).first
+        elsif env.has_key?('HTTP_X_FORWARDED_FOR')
+          @location = Geocoder.search(env['HTTP_X_FORWARDED_FOR']).first
+        else
+          @location = Geocoder.search(ip).first
+        end
       end
       @location
     end

data/lib/geocoder/results/base.rb

@@ -1,10 +1,16 @@
 module Geocoder
   module Result
     class Base
-      attr_accessor :data, :cache_hit
+
+      # data (hash) fetched from geocoding service
+      attr_accessor :data
+
+      # true if result came from cache, false if from request to geocoding
+      # service; nil if cache is not configured
+      attr_accessor :cache_hit
 
       ##
-      # Takes a hash of result data from a parsed Google result document.
+      # Takes a hash of data from a parsed geocoding service response.
       #
       def initialize(data)
         @data = data

data/lib/geocoder/results/google.rb

@@ -53,6 +53,12 @@ module Geocoder::Result
       end
     end
 
+    def route
+      if route = address_components_of_type(:route).first
+        route['long_name']
+      end
+    end
+
     def types
       @data['types']
     end

data/lib/geocoder/results/mapquest.rb

@@ -2,65 +2,50 @@ require 'geocoder/results/base'
 
 module Geocoder::Result
   class Mapquest < Base
-
-    def house_number
-      @data['address']['house_number']
+    def latitude
+      @data["latLng"]["lat"]
     end
 
-    def address
-      @data['display_name']
+    def longitude
+      @data["latLng"]["lng"]
     end
 
-    def street
-      @data['address']['road']
+    def coordinates
+      [latitude, longitude]
     end
 
     def city
-      @data['address']['city']
+      @data['adminArea5']
     end
 
-    def village
-      @data['address']['villiage']
-    end
-
-    def town
-      @data['address']['town']
+    def street
+      @data['street']
     end
 
     def state
-      @data['address']['state']
+      @data['adminArea3']
     end
 
     alias_method :state_code, :state
 
-    def postal_code
-      @data['address']['postcode']
-    end
+    #FIXME: these might not be right, unclear with MQ documentation
+    alias_method :provinice, :state
+    alias_method :province_code, :state
 
-    def county
-      @data['address']['county']
+    def postal_code
+      @data['postalCode'].to_s
     end
 
     def country
-      @data['address']['country']
+      @data['adminArea1']
     end
 
     def country_code
-      @data['address']['country_code']
-    end
-
-    def coordinates
-      [@data['lat'].to_f, @data['lon'].to_f]
-    end
-
-    def self.response_attributes
-      %w[place_id boundingbox license polygonpoints display_name class type stadium suburb]
+      country
     end
 
-    response_attributes.each do |a|
-      define_method a do
-        @data[a]
-      end
+    def address
+      [street, city, state, postal_code, country].reject{|s| s.length == 0 }.join(", ")
     end
   end
 end

data/lib/geocoder/results/maxmind.rb

@@ -0,0 +1,136 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Maxmind < Base
+
+    ##
+    # Hash mapping service names to names of returned fields.
+    #
+    def self.field_names
+      {
+        :country => [
+          :country_code,
+          :error
+        ],
+
+        :city => [
+          :country_code,
+          :region_code,
+          :city_name,
+          :latitude,
+          :longitude,
+          :error
+        ],
+
+        :city_isp_org => [
+          :country_code,
+          :region_code,
+          :city_name,
+          :postal_code,
+          :latitude,
+          :longitude,
+          :metro_code,
+          :area_code,
+          :isp_name,
+          :organization_name,
+          :error
+        ],
+
+        :omni => [
+          :country_code,
+          :country_name,
+          :region_code,
+          :region_name,
+          :city_name,
+          :latitude,
+          :longitude,
+          :metro_code,
+          :area_code,
+          :time_zone,
+          :continent_code,
+          :postal_code,
+          :isp_name,
+          :organization_name,
+          :domain,
+          :as_number,
+          :netspeed,
+          :user_type,
+          :accuracy_radius,
+          :country_confidence_factor,
+          :city_confidence_factor,
+          :region_confidence_factor,
+          :postal_confidence_factor,
+          :error
+        ]
+      }
+    end
+
+    ##
+    # Name of the MaxMind service being used.
+    # Inferred from format of @data.
+    #
+    def service_name
+      self.class.field_names.to_a.each do |n,f|
+        return n if f.size == @data.size
+      end
+      nil
+    end
+
+    def field_names
+      self.class.field_names[service_name]
+    end
+
+    def data_hash
+      @data_hash ||= Hash[*field_names.zip(@data).flatten]
+    end
+
+    def coordinates
+      [data_hash[:latitude].to_f, data_hash[:longitude].to_f]
+    end
+
+    def address(format = :full)
+      s = state_code.to_s == "" ? "" : ", #{state_code}"
+      "#{city}#{s} #{postal_code}, #{country_code}".sub(/^[ ,]*/, "")
+    end
+
+    def city
+      data_hash[:city_name]
+    end
+
+    def state # not given by MaxMind
+      data_hash[:region_name] || data_hash[:region_code]
+    end
+
+    def state_code
+      data_hash[:region_code]
+    end
+
+    def country #not given by MaxMind
+      data_hash[:country_name] || data_hash[:country_code]
+    end
+
+    def country_code
+      data_hash[:country_code]
+    end
+
+    def postal_code
+      data_hash[:postal_code]
+    end
+
+    def method_missing(method, *args, &block)
+      if field_names.include?(method)
+        data_hash[method]
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      if field_names.include?(method)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/geocoder/results/nominatim.rb

@@ -5,8 +5,9 @@ module Geocoder::Result
 
     def poi
       %w[stadium bus_stop tram_stop].each do |key|
-        @data['address'][key] if @data['address'].key?(key)
+        return @data['address'][key] if @data['address'].key?(key)
       end
+      return nil
     end
 
     def house_number
@@ -69,14 +70,24 @@ module Geocoder::Result
       [@data['lat'].to_f, @data['lon'].to_f]
     end
 
+    def place_class
+      @data['class']
+    end
+
+    def place_type
+      @data['type']
+    end
+
     def self.response_attributes
       %w[place_id osm_type osm_id boundingbox license
          polygonpoints display_name class type stadium]
     end
 
     response_attributes.each do |a|
-      define_method a do
-        @data[a]
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
       end
     end
   end

data/lib/geocoder/results/yahoo.rb

@@ -31,17 +31,24 @@ module Geocoder::Result
       @data['postal']
     end
 
+    def address_hash
+      @data['hash']
+    end
+
     def self.response_attributes
       %w[quality offsetlat offsetlon radius boundingbox name
         line1 line2 line3 line4 cross house street xstreet unittype unit
+        city state statecode country countrycode postal
         neighborhood county countycode
         level0 level1 level2 level3 level4 level0code level1code level2code
         timezone areacode uzip hash woeid woetype]
     end
 
     response_attributes.each do |a|
-      define_method a do
-        @data[a]
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
       end
     end
   end