geocoder 1.1.5 → 1.1.6

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)
-      "#{protocol}://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/query.rb

@@ -36,17 +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?
-      # check whether both coordinates given
-      if text.is_a?(Array)
-        text.compact.size < 2
-      # else assume a string
-      else
-        !!text.to_s.match(/^\s*$/)
-      end
+      !params_given? and (
+        (text.is_a?(Array) and text.compact.size < 2) or
+        text.to_s.match(/^\s*$/)
+      )
     end
 
     ##
@@ -90,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']).first
+        else
+          @location = Geocoder.search(ip).first
+        end
       end
       @location
     end

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/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

@@ -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/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( " +

data/lib/geocoder/stores/active_record.rb

@@ -87,19 +87,19 @@ module Geocoder::Store
       # * +:units+   - <tt>:mi</tt> or <tt>:km</tt>; to be used.
       #   for interpreting radius as well as the +distance+ attribute which
       #   is added to each found nearby object.
-      #   See Geocoder::Configuration to know how configure default units.
+      #   Use Geocoder.configure[:units] to configure default units.
       # * +:bearing+ - <tt>:linear</tt> or <tt>:spherical</tt>.
       #   the method to be used for calculating the bearing (direction)
       #   between the given point and each found nearby point;
-      #   set to false for no bearing calculation.
-      #   See Geocoder::Configuration to know how configure default method.
+      #   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)
       #
       def near_scope_options(latitude, longitude, radius = 20, options = {})
-        options[:units] ||= (geocoder_options[:units] || Geocoder::Configuration.units)
+        options[:units] ||= (geocoder_options[:units] || Geocoder.config.units)
         bearing = bearing_sql(latitude, longitude, options)
         distance = distance_sql(latitude, longitude, options)
 
@@ -143,7 +143,7 @@ module Geocoder::Store
       #
       def bearing_sql(latitude, longitude, options = {})
         if !options.include?(:bearing)
-          options[:bearing] = Geocoder::Configuration.distances
+          options[:bearing] = Geocoder.config.distances
         end
         if options[:bearing]
           method_prefix = using_sqlite? ? "approx" : "full"

data/lib/geocoder/stores/base.rb

@@ -58,10 +58,11 @@ module Geocoder
       ##
       # Get nearby geocoded objects.
       # Takes the same options hash as the near class method (scope).
+      # Returns nil if the object is not geocoded.
       #
       def nearbys(radius = 20, options = {})
-        return [] unless geocoded? # TODO: return ActiveRecord::Relation, not Array
-        options.merge!(:exclude => self)
+        return nil unless geocoded?
+        options.merge!(:exclude => self) unless send(self.class.primary_key).nil?
         self.class.near(self, radius, options)
       end
 

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.1.5"
+  VERSION = "1.1.6"
 end

data/lib/hash_recursive_merge.rb

@@ -0,0 +1,74 @@
+# 
+# = Hash Recursive Merge
+# 
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+# 
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      http://gist.github.com/gists/6391/
+#
+module HashRecursiveMerge
+
+  #
+  # Recursive version of Hash#merge!
+  # 
+  # Adds the contents of +other_hash+ to +hsh+, 
+  # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge!(h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #    
+  # Simply using Hash#merge! would return
+  # 
+  #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  # 
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+      oldval.class == self.class ? oldval.rmerge!(newval) : newval
+    end
+  end
+
+  #
+  # Recursive version of Hash#merge
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  # Compared with Hash#merge, this method provides a different approch
+  # for merging nasted hashes.
+  # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+  # includes the same key, the value is merged instead replaced with
+  # +other_hash+ value.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge(h2)    #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #    
+  # Simply using Hash#merge would return
+  # 
+  #    h1.merge(h2)     #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  # 
+  def rmerge(other_hash)
+    r = {}
+    merge(other_hash) do |key, oldval, newval|
+      r[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
+  end
+
+end
+
+
+class Hash
+  include HashRecursiveMerge
+end

data/lib/oauth_util.rb

@@ -3,6 +3,13 @@
 # Source: http://gist.github.com/383159
 # License: http://gist.github.com/375593
 # Usage: see example.rb below
+#
+# NOTE: This file has been modified from the original Gist:
+#
+# 1. Fix to prevent param-array conversion, as mentioned in Gist comment.
+# 2. Query string escaping has been changed. See:
+#   https://github.com/alexreisner/geocoder/pull/360
+#
 
 require 'uri'
 require 'cgi'
@@ -56,7 +63,7 @@ class OauthUtil
   def query_string
     pairs = []
     @params.sort.each { | key, val | 
-      pairs.push( "#{ percent_encode( key ) }=#{ percent_encode( val.to_s ) }" )
+      pairs.push( "#{ CGI.escape(key.to_s).gsub(/%(5B|5D)/n) { [$1].pack('H*') } }=#{ CGI.escape(val.to_s) }" )
     }
     pairs.join '&'
   end
@@ -74,7 +81,6 @@ class OauthUtil
 
     # if url has query, merge key/values into params obj overwriting defaults
     if parsed_url.query
-      #@params.merge! CGI.parse( parsed_url.query )
       CGI.parse( parsed_url.query ).each do |k,v|
         if v.is_a?(Array) && v.count == 1
           @params[k] = v.first