geocoder 1.1.4 → 1.1.8

data/lib/geocoder/query.rb

@@ -36,11 +36,20 @@ module Geocoder
       Lookup.get(name)
     end
 
+    def url
+      lookup.query_url(self)
+    end
+
     ##
-    # Is the Query text blank? (ie, should we not bother searching?)
+    # 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?
-      !!text.to_s.match(/^\s*$/)
+      !params_given? and (
+        (text.is_a?(Array) and text.compact.size < 2) or
+        text.to_s.match(/\A\s*\z/)
+      )
     end
 
     ##
@@ -50,14 +59,14 @@ module Geocoder
     # dot-delimited numbers.
     #
     def ip_address?
-      !!text.to_s.match(/^(::ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+      !!text.to_s.match(/\A(::ffff:)?(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\z/)
     end
 
     ##
     # Is the Query text a loopback IP address?
     #
     def loopback_ip_address?
-      !!(text == "0.0.0.0" or text.to_s.match(/^127/))
+      !!(self.ip_address? and (text == "0.0.0.0" or text.to_s.match(/\A127/)))
     end
 
     ##
@@ -66,7 +75,7 @@ module Geocoder
     def coordinates?
       text.is_a?(Array) or (
         text.is_a?(String) and
-        !!text.to_s.match(/^-?[0-9\.]+, *-?[0-9\.]+$/)
+        !!text.to_s.match(/\A-?[0-9\.]+, *-?[0-9\.]+\z/)
       )
     end
 
@@ -84,5 +93,11 @@ module Geocoder
     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'].split(/\s*,\s*/)[0]).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/esri.rb

@@ -0,0 +1,51 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Esri < Base
+
+    def address
+      address = reverse_geocode? ? 'Address' : 'Match_addr'
+      attributes[address]
+    end
+
+    def city
+      attributes['City']
+    end
+
+    def state_code
+      attributes['Region']
+    end
+
+    alias_method :state, :state_code
+
+    def country
+      country = reverse_geocode? ? "CountryCode" : "Country"
+      attributes[country]
+    end
+
+    alias_method :country_code, :country
+
+    def postal_code
+      attributes['Postal']
+    end
+
+    def coordinates
+      [geometry["y"], geometry["x"]]
+    end
+
+    private
+
+    def attributes
+      reverse_geocode? ? @data['address'] : @data['locations'].first['feature']['attributes']
+    end
+
+    def geometry
+      reverse_geocode? ? @data["location"] : @data['locations'].first['feature']["geometry"]
+    end
+
+    def reverse_geocode?
+      @data['locations'].nil?
+    end
+
+  end
+end

data/lib/geocoder/results/google.rb

@@ -11,6 +11,12 @@ module Geocoder::Result
       formatted_address
     end
 
+    def neighborhood
+      if neighborhood = address_components_of_type(:neighborhood).first
+        neighborhood['long_name']
+      end
+    end
+
     def city
       fields = [:locality, :sublocality,
         :administrative_area_level_3,
@@ -35,6 +41,18 @@ module Geocoder::Result
       end
     end
 
+    def sub_state
+      if state = address_components_of_type(:administrative_area_level_2).first
+        state['long_name']
+      end
+    end
+
+    def sub_state_code
+      if state = address_components_of_type(:administrative_area_level_2).first
+        state['short_name']
+      end
+    end
+
     def country
       if country = address_components_of_type(:country).first
         country['long_name']
@@ -53,6 +71,22 @@ module Geocoder::Result
       end
     end
 
+    def route
+      if route = address_components_of_type(:route).first
+        route['long_name']
+      end
+    end
+
+    def street_number
+      if street_number = address_components_of_type(:street_number).first
+        street_number['long_name']
+      end
+    end
+
+    def street_address
+      [street_number, route].compact.join(' ')
+    end
+
     def types
       @data['types']
     end

data/lib/geocoder/results/mapquest.rb

@@ -1,7 +1,51 @@
 require 'geocoder/results/base'
-require 'geocoder/results/nominatim'
 
 module Geocoder::Result
-  class Mapquest < Nominatim
+  class Mapquest < Base
+    def latitude
+      @data["latLng"]["lat"]
+    end
+
+    def longitude
+      @data["latLng"]["lng"]
+    end
+
+    def coordinates
+      [latitude, longitude]
+    end
+
+    def city
+      @data['adminArea5']
+    end
+
+    def street
+      @data['street']
+    end
+
+    def state
+      @data['adminArea3']
+    end
+
+    alias_method :state_code, :state
+
+    #FIXME: these might not be right, unclear with MQ documentation
+    alias_method :province, :state
+    alias_method :province_code, :state
+
+    def postal_code
+      @data['postalCode'].to_s
+    end
+
+    def country
+      @data['adminArea1']
+    end
+
+    def country_code
+      country
+    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,135 @@
+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.
+    #
+    def service_name
+      # it would be much better to infer this from the length of the @data
+      # array, but MaxMind seems to send inconsistent and wide-ranging response
+      # lengths (see https://github.com/alexreisner/geocoder/issues/396)
+      Geocoder.config.maxmind[:service]
+    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

@@ -83,16 +83,6 @@ module Geocoder::Result
          polygonpoints display_name class type stadium]
     end
 
-    def class
-      warn "DEPRECATION WARNING: The 'class' method of Geocoder::Result::Nominatim objects is deprecated and will be removed in Geocoder version 1.2.0. Please use 'place_class' instead."
-      @data['class']
-    end
-
-    def type
-      warn "DEPRECATION WARNING: The 'type' method of Geocoder::Result::Nominatim objects is deprecated and will be removed in Geocoder version 1.2.0. Please use 'place_type' instead."
-      @data['type']
-    end
-
     response_attributes.each do |a|
       unless method_defined?(a)
         define_method a do

data/lib/geocoder/results/ovi.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Ovi < Base
+
+    ##
+    # A string in the given format.
+    #
+    def address(format = :full)
+      address_data['Label']
+    end
+
+    ##
+    # A two-element array: [lat, lon].
+    #
+    def coordinates
+      fail unless d = @data['Location']['DisplayPosition']
+      [d['Latitude'].to_f, d['Longitude'].to_f]
+    end
+
+    def state
+      address_data['County']
+    end
+
+    def province
+      address_data['County']
+    end
+
+    def postal_code
+      address_data['PostalCode']
+    end
+
+    def city
+      address_data['City']
+    end
+
+    def state_code
+      address_data['State']
+    end
+
+    def province_code
+      address_data['State']
+    end
+
+    def country
+      fail unless d = address_data['AdditionalData']
+      if v = d.find{|ad| ad['key']=='CountryName'}
+        return v['value']
+      end
+    end
+
+    def country_code
+      address_data['Country']
+    end
+
+    private # ----------------------------------------------------------------
+
+    def address_data
+      @data['Location']['Address'] || fail
+    end
+  end
+end

data/lib/geocoder/results/test.rb

@@ -5,7 +5,8 @@ module Geocoder
     class Test < Base
 
       %w[latitude longitude city state state_code province
-      province_code postal_code country country_code address].each do |attr|
+      province_code postal_code country country_code address
+      street_address street_number route].each do |attr|
         define_method(attr) do
           @data[attr.to_s] || @data[attr.to_sym]
         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

data/lib/geocoder/results/yandex.rb

@@ -16,8 +16,10 @@ module Geocoder::Result
         address_details['Locality']['LocalityName']
       elsif sub_state.empty?
         address_details['AdministrativeArea']['Locality']['LocalityName']
-      else 
-        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName']
+      elsif not sub_state_city.empty?
+        sub_state_city
+      else
+        ""
       end
     end
 
@@ -66,5 +68,13 @@ module Geocoder::Result
     def address_details
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
     end
+
+    def sub_state_city
+      if sub_state && sub_state["Locality"]
+        sub_state['Locality']['LocalityName']          
+      else
+        ""
+      end
+    end
   end
 end

data/lib/geocoder/sql.rb

@@ -11,7 +11,8 @@ module Geocoder
     # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
     #
     def full_distance(latitude, longitude, lat_attr, lon_attr, options = {})
-      earth = Geocoder::Calculations.earth_radius(options[:units] || :mi)
+      units = options[:units] || Geocoder.config.units
+      earth = Geocoder::Calculations.earth_radius(units)
 
       "#{earth} * 2 * ASIN(SQRT(" +
         "POWER(SIN((#{latitude.to_f} - #{lat_attr}) * PI() / 180 / 2), 2) + " +
@@ -31,8 +32,9 @@ module Geocoder
     # are not intended for use in production!
     #
     def approx_distance(latitude, longitude, lat_attr, lon_attr, options = {})
-      dx = Geocoder::Calculations.longitude_degree_distance(30, options[:units] || :mi)
-      dy = Geocoder::Calculations.latitude_degree_distance(options[:units] || :mi)
+      units = options[:units] || Geocoder.config.units
+      dx = Geocoder::Calculations.longitude_degree_distance(30, units)
+      dy = Geocoder::Calculations.latitude_degree_distance(units)
 
       # sin of 45 degrees = average x or y component of vector
       factor = Math.sin(Math::PI / 4)
@@ -61,7 +63,7 @@ module Geocoder
     # http://www.beginningspatial.com/calculating_bearing_one_point_another
     #
     def full_bearing(latitude, longitude, lat_attr, lon_attr, options = {})
-      case options[:bearing]
+      case options[:bearing] || Geocoder.config.distances
       when :linear
         "CAST(" +
           "DEGREES(ATAN2( " +