geocoder 1.1.6 → 1.1.7

data/lib/geocoder/lookups/maxmind.rb

@@ -15,9 +15,12 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
-    def service_code
+    ##
+    # Return the name of the configured service, or raise an exception.
+    #
+    def configured_service!
       if s = configuration[:service] and services.keys.include?(s)
-        services[s]
+        return s
       else
         raise(
           Geocoder::ConfigurationError,
@@ -28,6 +31,19 @@ module Geocoder::Lookup
       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.
     #
@@ -45,7 +61,7 @@ module Geocoder::Lookup
       return [reserved_result] if query.loopback_ip_address?
       doc = fetch_data(query)
       if doc and doc.is_a?(Array)
-        if doc.last.nil?
+        if !data_contains_error?(doc)
           return [doc]
         elsif doc.last == "INVALID_LICENSE_KEY"
           raise_error(Geocoder::InvalidApiKey) || warn("Invalid MaxMind API key.")

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

@@ -13,8 +13,13 @@ module Geocoder
         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
@@ -25,6 +30,7 @@ module Geocoder
 
       def self.reset
         @stubs = {}
+        @default_stub = nil
       end
 
       private

data/lib/geocoder/lookups/yahoo.rb

@@ -46,13 +46,15 @@ module Geocoder::Lookup
     # 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 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.")
+        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)

data/lib/geocoder/query.rb

@@ -48,7 +48,7 @@ module Geocoder
     def blank?
       !params_given? and (
         (text.is_a?(Array) and text.compact.size < 2) or
-        text.to_s.match(/^\s*$/)
+        text.to_s.match(/\A\s*\z/)
       )
     end
 
@@ -59,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
 
     ##
@@ -75,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
 

data/lib/geocoder/request.rb

@@ -8,7 +8,7 @@ module Geocoder
         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
+          @location = Geocoder.search(env['HTTP_X_FORWARDED_FOR'].split(/\s*,\s*/)[0]).first
         else
           @location = Geocoder.search(ip).first
         end

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']
@@ -59,6 +77,16 @@ module Geocoder::Result
       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

@@ -29,7 +29,7 @@ module Geocoder::Result
     alias_method :state_code, :state
 
     #FIXME: these might not be right, unclear with MQ documentation
-    alias_method :provinice, :state
+    alias_method :province, :state
     alias_method :province_code, :state
 
     def postal_code

data/lib/geocoder/results/maxmind.rb

@@ -67,13 +67,12 @@ module Geocoder::Result
 
     ##
     # 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
+      # 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

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/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/stores/active_record.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'geocoder/sql'
 require 'geocoder/stores/base'
 
@@ -17,13 +18,15 @@ module Geocoder::Store
 
         # scope: geocoded objects
         scope :geocoded, lambda {
-          {:conditions => "#{geocoder_options[:latitude]} IS NOT NULL " +
-            "AND #{geocoder_options[:longitude]} IS NOT NULL"}}
+          where("#{geocoder_options[:latitude]} IS NOT NULL " +
+            "AND #{geocoder_options[:longitude]} IS NOT NULL")
+        }
 
         # scope: not-geocoded objects
         scope :not_geocoded, lambda {
-          {:conditions => "#{geocoder_options[:latitude]} IS NULL " +
-            "OR #{geocoder_options[:longitude]} IS NULL"}}
+          where("#{geocoder_options[:latitude]} IS NULL " +
+            "OR #{geocoder_options[:longitude]} IS NULL")
+        }
 
         ##
         # Find all objects within a radius of the given location.
@@ -35,7 +38,9 @@ module Geocoder::Store
         scope :near, lambda{ |location, *args|
           latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
           if Geocoder::Calculations.coordinates_present?(latitude, longitude)
-            near_scope_options(latitude, longitude, *args)
+            options = near_scope_options(latitude, longitude, *args)
+            select(options[:select]).where(options[:conditions]).
+              order(options[:order])
           else
             # If no lat/lon given we don't want any results, but we still
             # need distance and bearing columns so you can add, for example:
@@ -53,11 +58,11 @@ module Geocoder::Store
         scope :within_bounding_box, lambda{ |bounds|
           sw_lat, sw_lng, ne_lat, ne_lng = bounds.flatten if bounds
           if sw_lat && sw_lng && ne_lat && ne_lng
-            {:conditions => Geocoder::Sql.within_bounding_box(
+            where(Geocoder::Sql.within_bounding_box(
               sw_lat, sw_lng, ne_lat, ne_lng,
               full_column_name(geocoder_options[:latitude]),
               full_column_name(geocoder_options[:longitude])
-            )}
+            ))
           else
             select(select_clause(nil, "NULL", "NULL")).where(false_condition)
           end
@@ -93,13 +98,22 @@ module Geocoder::Store
       #   between the given point and each found nearby point;
       #   set to false for no bearing calculation. Use
       #   Geocoder.configure[:distances] to configure default calculation method.
-      # * +:select+  - string with the SELECT SQL fragment (e.g. “id, name”)
-      # * +:order+   - column(s) for ORDER BY SQL clause; default is distance;
-      #                set to false or nil to omit the ORDER BY clause
-      # * +:exclude+ - an object to exclude (used by the +nearbys+ method)
+      # * +:select+          - string with the SELECT SQL fragment (e.g. “id, name”)
+      # * +:select_distance+ - whether to include the distance alias in the
+      #                        SELECT SQL fragment (e.g. <formula> AS distance)
+      # * +:select_bearing+  - like +:select_distance+ but for bearing.
+      # * +:order+           - column(s) for ORDER BY SQL clause; default is distance;
+      #                        set to false or nil to omit the ORDER BY clause
+      # * +:exclude+         - an object to exclude (used by the +nearbys+ method)
       #
       def near_scope_options(latitude, longitude, radius = 20, options = {})
+        if options[:units]
+          options[:units] = options[:units].to_sym
+        end
         options[:units] ||= (geocoder_options[:units] || Geocoder.config.units)
+        select_distance = options.fetch(:select_distance, true)
+        options[:order] = "" if !select_distance && !options.include?(:order)
+        select_bearing = options.fetch(:select_bearing, true)
         bearing = bearing_sql(latitude, longitude, options)
         distance = distance_sql(latitude, longitude, options)
 
@@ -116,7 +130,9 @@ module Geocoder::Store
           conditions = [bounding_box_conditions + " AND #{distance} <= ?", radius]
         end
         {
-          :select => select_clause(options[:select], distance, bearing),
+          :select => select_clause(options[:select],
+                                   select_distance ? distance : nil,
+                                   select_bearing ? bearing : nil),
           :conditions => add_exclude_condition(conditions, options[:exclude]),
           :order => options.include?(:order) ? options[:order] : "distance ASC"
         }
@@ -166,10 +182,17 @@ module Geocoder::Store
         elsif columns == :geo_only
           clause = ""
         else
-          clause = (columns || full_column_name("*")) + ", "
+          clause = (columns || full_column_name("*"))
         end
-        clause + "#{distance} AS distance" +
-          (bearing ? ", #{bearing} AS bearing" : "")
+        if distance
+          clause += ", " unless clause.empty?
+          clause += "#{distance} AS distance"
+        end
+        if bearing
+          clause += ", " unless clause.empty?
+          clause += "#{bearing} AS bearing"
+        end
+        clause
       end
 
       ##
@@ -241,4 +264,3 @@ module Geocoder::Store
     alias_method :fetch_address, :reverse_geocode
   end
 end
-