rails-geocoder 0.9.10 → 0.9.11

data/lib/geocoder/lookups/google.rb

@@ -6,10 +6,10 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
-    def result(query, reverse = false)
-      doc = fetch_data(query, reverse)
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query, reverse)
       case doc['status']; when "OK" # OK status implies >0 results
-        doc['results'].first
+        return doc['results']
       when "OVER_QUERY_LIMIT"
         warn "Google Geocoding API error: over query limit."
       when "REQUEST_DENIED"
@@ -17,14 +17,17 @@ module Geocoder::Lookup
       when "INVALID_REQUEST"
         warn "Google Geocoding API error: invalid request."
       end
+      return []
     end
 
     def query_url(query, reverse = false)
       params = {
         (reverse ? :latlng : :address) => query,
-        :sensor => "false"
+        :sensor => "false",
+        :language => Geocoder::Configuration.language,
+        :key => Geocoder::Configuration.api_key
       }
-      "http://maps.google.com/maps/api/geocode/json?" + hash_to_query(params)
+      "#{protocol}://maps.google.com/maps/api/geocode/json?" + hash_to_query(params)
     end
   end
 end

data/lib/geocoder/lookups/yahoo.rb

@@ -6,12 +6,13 @@ module Geocoder::Lookup
 
     private # ---------------------------------------------------------------
 
-    def result(query, reverse = false)
-      doc = fetch_data(query, reverse)
+    def results(query, reverse = false)
+      return [] unless doc = fetch_data(query, reverse)
       if doc = doc['ResultSet'] and doc['Error'] == 0
-        doc['Results'].first if doc['Found'] > 0
+        return doc['Found'] > 0 ? doc['Results'] : []
       else
         warn "Yahoo Geocoding API error: #{doc['Error']} (#{doc['ErrorMessage']})."
+        return []
       end
     end
 
@@ -20,7 +21,8 @@ module Geocoder::Lookup
         :location =>  query,
         :flags => "JXTSR",
         :gflags => "AC#{'R' if reverse}",
-        :appid => Geocoder::Configuration.yahoo_appid
+        :locale => "#{Geocoder::Configuration.language}_US",
+        :appid => Geocoder::Configuration.api_key
       }
       "http://where.yahooapis.com/geocode?" + hash_to_query(params)
     end

data/lib/geocoder/orms/active_record.rb

@@ -27,9 +27,11 @@ module Geocoder::Orm
             "OR #{geocoder_options[:longitude]} IS NULL"}}
 
         ##
-        # Find all objects within a radius (in miles) of the given location
-        # (address string). Location (the first argument) may be either a string
-        # to geocode or an array of coordinates (<tt>[lat,long]</tt>).
+        # Find all objects within a radius of the given location.
+        # Location may be either a string to geocode or an array of
+        # coordinates (<tt>[lat,lon]</tt>). Also takes an options hash
+        # (see Geocoder::Orm::ActiveRecord::ClassMethods.near_scope_options
+        # for details).
         #
         scope :near, lambda{ |location, *args|
           latitude, longitude = location.is_a?(Array) ?
@@ -53,16 +55,22 @@ module Geocoder::Orm
       # records within a radius (in miles) of the given point.
       # Options hash may include:
       #
-      # +units+   :: <tt>:mi</tt> (default) or <tt>:km</tt>
-      # +exclude+ :: an object to exclude (used by the #nearbys method)
-      # +order+   :: column(s) for ORDER BY SQL clause
-      # +limit+   :: number of records to return (for LIMIT SQL clause)
-      # +offset+  :: number of records to skip (for OFFSET SQL clause)
-      # +select+  :: string with the SELECT SQL fragment (e.g. “id, name”)
+      # * +:units+   - <tt>:mi</tt> (default) or <tt>:km</tt>; to be used
+      #   for interpreting radius as well as the +distance+ attribute which
+      #   is added to each found nearby object
+      # * +:bearing+ - <tt>:linear</tt> (default) 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
+      # * +:select+  - string with the SELECT SQL fragment (e.g. “id, name”)
+      # * +:order+   - column(s) for ORDER BY SQL clause
+      # * +:limit+   - number of records to return (for LIMIT SQL clause)
+      # * +:offset+  - number of records to skip (for OFFSET SQL clause)
+      # * +:exclude+ - an object to exclude (used by the +nearbys+ method)
       #
       def near_scope_options(latitude, longitude, radius = 20, options = {})
         radius *= Geocoder::Calculations.km_in_mi if options[:units] == :km
-        if ::ActiveRecord::Base.connection.adapter_name == "SQLite"
+        if connection.adapter_name.match /sqlite/i
           approx_near_scope_options(latitude, longitude, radius, options)
         else
           full_near_scope_options(latitude, longitude, radius, options)
@@ -74,23 +82,50 @@ module Geocoder::Orm
 
       ##
       # Scope options hash for use with a database that supports POWER(),
-      # SQRT(), PI(), and trigonometric functions (SIN(), COS(), and ASIN()).
+      # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
+      # ATAN2(), DEGREES(), and RADIANS().
       #
-      # Taken from the excellent tutorial at:
+      # Distance calculations based on the excellent tutorial at:
       # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
       #
+      # Bearing calculation based on:
+      # http://www.beginningspatial.com/calculating_bearing_one_point_another
+      #
       def full_near_scope_options(latitude, longitude, radius, options)
         lat_attr = geocoder_options[:latitude]
         lon_attr = geocoder_options[:longitude]
-        distance = "3956 * 2 * ASIN(SQRT(" +
-          "POWER(SIN((#{latitude} - #{lat_attr}) * " +
-          "PI() / 180 / 2), 2) + COS(#{latitude} * PI()/180) * " +
-          "COS(#{lat_attr} * PI() / 180) * " +
-          "POWER(SIN((#{longitude} - #{lon_attr}) * " +
-          "PI() / 180 / 2), 2) ))"
+        options[:bearing] = :linear unless options.include?(:bearing)
+        bearing = case options[:bearing]
+        when :linear
+          "CAST(" +
+            "DEGREES(ATAN2( " +
+              "RADIANS(#{lon_attr} - #{longitude}), " +
+              "RADIANS(#{lat_attr} - #{latitude})" +
+            ")) + 360 " +
+          "AS decimal) % 360"
+        when :spherical
+          "CAST(" +
+            "DEGREES(ATAN2( " +
+              "SIN(RADIANS(#{lon_attr} - #{longitude})) * " +
+              "COS(RADIANS(#{lat_attr})), (" +
+                "COS(RADIANS(#{latitude})) * SIN(RADIANS(#{lat_attr}))" +
+              ") - (" +
+                "SIN(RADIANS(#{latitude})) * COS(RADIANS(#{lat_attr})) * " +
+                "COS(RADIANS(#{lon_attr} - #{longitude}))" +
+              ")" +
+            ")) + 360 " +
+          "AS decimal) % 360"
+        end
+        earth = Geocoder::Calculations.earth_radius(options[:units] || :mi)
+        distance = "#{earth} * 2 * ASIN(SQRT(" +
+          "POWER(SIN((#{latitude} - #{lat_attr}) * PI() / 180 / 2), 2) + " +
+          "COS(#{latitude} * PI() / 180) * COS(#{lat_attr} * PI() / 180) * " +
+          "POWER(SIN((#{longitude} - #{lon_attr}) * PI() / 180 / 2), 2) ))"
         options[:order] ||= "#{distance} ASC"
         default_near_scope_options(latitude, longitude, radius, options).merge(
-          :select => "#{options[:select] || '*'}, #{distance} AS distance",
+          :select => "#{options[:select] || '*'}, " +
+            "#{distance} AS distance" +
+            (bearing ? ", #{bearing} AS bearing" : ""),
           :having => "#{distance} <= #{radius}"
         )
       end
@@ -101,9 +136,33 @@ module Geocoder::Orm
       # rather than a circle, so results are very approximate (will include
       # objects outside the given radius).
       #
+      # Distance and bearing calculations are *extremely inaccurate*. They
+      # only exist for interface consistency--not intended for production!
+      #
       def approx_near_scope_options(latitude, longitude, radius, options)
+        lat_attr = geocoder_options[:latitude]
+        lon_attr = geocoder_options[:longitude]
+        options[:bearing] = :linear unless options.include?(:bearing)
+        if options[:bearing]
+          bearing = "CASE " +
+            "WHEN (#{lat_attr} >= #{latitude} AND #{lon_attr} >= #{longitude}) THEN  45.0 " +
+            "WHEN (#{lat_attr} <  #{latitude} AND #{lon_attr} >= #{longitude}) THEN 135.0 " +
+            "WHEN (#{lat_attr} <  #{latitude} AND #{lon_attr} <  #{longitude}) THEN 225.0 " +
+            "WHEN (#{lat_attr} >= #{latitude} AND #{lon_attr} <  #{longitude}) THEN 315.0 " +
+          "END"
+        else
+          bearing = false
+        end
+
+        dx = Geocoder::Calculations.longitude_degree_distance(30, options[:units] || :mi)
+        dy = Geocoder::Calculations.latitude_degree_distance(options[:units] || :mi)
+
+        distance = "(#{dy} * ABS(#{lat_attr} - #{latitude}) / 2) + " +
+          "(#{dx} * ABS(#{lon_attr} - #{longitude}) / 2)"
         default_near_scope_options(latitude, longitude, radius, options).merge(
-          :select => options[:select] || nil
+          :select => "#{options[:select] || '*'}, " +
+            "#{distance} AS distance" +
+            (bearing ? ", #{bearing} AS bearing" : "")
         )
       end
 
@@ -113,9 +172,10 @@ module Geocoder::Orm
       def default_near_scope_options(latitude, longitude, radius, options)
         lat_attr = geocoder_options[:latitude]
         lon_attr = geocoder_options[:longitude]
+        b = Geocoder::Calculations.bounding_box(latitude, longitude, radius, options)
         conditions = \
           ["#{lat_attr} BETWEEN ? AND ? AND #{lon_attr} BETWEEN ? AND ?"] +
-          coordinate_bounds(latitude, longitude, radius)
+          [b[0], b[2], b[1], b[3]]
         if obj = options[:exclude]
           conditions[0] << " AND #{table_name}.id != ?"
           conditions << obj.id
@@ -128,22 +188,6 @@ module Geocoder::Orm
           :conditions => conditions
         }
       end
-
-      ##
-      # Get the rough high/low lat/long bounds for a geographic point and
-      # radius. Returns an array: <tt>[lat_lo, lat_hi, lon_lo, lon_hi]</tt>.
-      # Used to constrain search to a (radius x radius) square.
-      #
-      def coordinate_bounds(latitude, longitude, radius)
-        radius = radius.to_f
-        factor = (Math::cos(latitude * Math::PI / 180.0) * 69.0).abs
-        [
-          latitude  - (radius / 69.0),
-          latitude  + (radius / 69.0),
-          longitude - (radius / factor),
-          longitude + (radius / factor)
-        ]
-      end
     end
 
     ##
@@ -151,7 +195,8 @@ module Geocoder::Orm
     # (or other as specified in +geocoded_by+). Returns coordinates (array).
     #
     def geocode
-      do_lookup(false) do |o,r|
+      do_lookup(false) do |o,rs|
+        r = rs.first
         unless r.latitude.nil? or r.longitude.nil?
           o.send :write_attribute, self.class.geocoder_options[:latitude],  r.latitude
           o.send :write_attribute, self.class.geocoder_options[:longitude], r.longitude
@@ -167,7 +212,8 @@ module Geocoder::Orm
     # in +reverse_geocoded_by+). Returns address (string).
     #
     def reverse_geocode
-      do_lookup(true) do |o,r|
+      do_lookup(true) do |o,rs|
+        r = rs.first
         unless r.address.nil?
           o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
         end

data/lib/geocoder/orms/active_record_legacy.rb

@@ -7,7 +7,8 @@ module Geocoder::Orm::ActiveRecord
     def fetch_coordinates!
       warn "DEPRECATION WARNING: The 'fetch_coordinates!' method is deprecated and will be removed in geocoder v1.0. " +
         "Please use 'geocode' instead and then save your objects manually."
-      do_lookup(false) do |o,r|
+      do_lookup(false) do |o,rs|
+        r = rs.first
         unless r.latitude.nil? or r.longitude.nil?
           o.send :update_attribute, self.class.geocoder_options[:latitude],  r.latitude
           o.send :update_attribute, self.class.geocoder_options[:longitude], r.longitude
@@ -19,7 +20,8 @@ module Geocoder::Orm::ActiveRecord
     def fetch_coordinates(*args)
       warn "DEPRECATION WARNING: The 'fetch_coordinates' method will cease taking " +
         "an argument in geocoder v1.0. Please save your objects manually." if args.size > 0
-      do_lookup(false) do |o,r|
+      do_lookup(false) do |o,rs|
+        r = rs.first
         unless r.latitude.nil? or r.longitude.nil?
           method = ((args.size > 0 && args.first) ? "update" : "write" ) + "_attribute"
           o.send method, self.class.geocoder_options[:latitude],  r.latitude
@@ -35,7 +37,8 @@ module Geocoder::Orm::ActiveRecord
     def fetch_address!
       warn "DEPRECATION WARNING: The 'fetch_address!' method is deprecated and will be removed in geocoder v1.0. " +
         "Please use 'reverse_geocode' instead and then save your objects manually."
-      do_lookup(true) do |o,r|
+      do_lookup(true) do |o,rs|
+        r = rs.first
         unless r.address.nil?
           o.send :update_attribute, self.class.geocoder_options[:fetched_address], r.address
         end
@@ -46,7 +49,8 @@ module Geocoder::Orm::ActiveRecord
     def fetch_address(*args)
       warn "DEPRECATION WARNING: The 'fetch_address' method will cease taking " +
         "an argument in geocoder v1.0. Please save your objects manually." if args.size > 0
-      do_lookup(true) do |o,r|
+      do_lookup(true) do |o,rs|
+        r = rs.first
         unless r.latitude.nil? or r.longitude.nil?
           method = ((args.size > 0 && args.first) ? "update" : "write" ) + "_attribute"
           o.send method, self.class.geocoder_options[:fetched_address], r.address

data/lib/geocoder/orms/base.rb

@@ -6,7 +6,14 @@ module Geocoder
       # Is this object geocoded? (Does it have latitude and longitude?)
       #
       def geocoded?
-        read_coordinates.compact.size > 0
+        to_coordinates.compact.size > 0
+      end
+
+      ##
+      # Coordinates [lat,lon] of the object.
+      #
+      def to_coordinates
+        [:latitude, :longitude].map{ |i| send self.class.geocoder_options[i] }
       end
 
       ##
@@ -16,20 +23,24 @@ module Geocoder
       #
       def distance_to(lat, lon, units = :mi)
         return nil unless geocoded?
-        mylat,mylon = read_coordinates
+        mylat,mylon = to_coordinates
         Geocoder::Calculations.distance_between(mylat, mylon, lat, lon, :units => units)
       end
 
       alias_method :distance_from, :distance_to
 
       ##
-      # Get nearby geocoded objects. Takes a radius (integer) and a symbol
-      # representing the units of the ratius (:mi or :km; default is :mi).
+      # Get nearby geocoded objects.
+      # Takes the same options hash as the near class method (scope).
       #
-      def nearbys(radius = 20, units = :mi)
+      def nearbys(radius = 20, options = {})
         return [] unless geocoded?
-        options = {:exclude => self, :units => units}
-        self.class.near(read_coordinates, radius, options)
+        if options.is_a?(Symbol)
+          options = {:units => options}
+          warn "DEPRECATION WARNING: The units argument to the nearbys method has been replaced with an options hash (same options hash as the near scope). You should instead call: obj.nearbys(#{radius}, :units => #{options[:units]}). The old syntax will not be supported in Geocoder v1.0."
+        end
+        options.merge!(:exclude => self)
+        self.class.near(to_coordinates, radius, options)
       end
 
       ##
@@ -53,10 +64,10 @@ module Geocoder
 
       ##
       # Look up geographic data based on object attributes (configured in
-      # geocoded_by or reverse_geocoded_by) and handle the result with the
+      # geocoded_by or reverse_geocoded_by) and handle the results with the
       # block (given to geocoded_by or reverse_geocoded_by). The block is
-      # given two-arguments: the object being geocoded and a
-      # Geocoder::Result object with the geocoding results).
+      # given two-arguments: the object being geocoded and an array of
+      # Geocoder::Result objects).
       #
       def do_lookup(reverse = false)
         options = self.class.geocoder_options
@@ -69,28 +80,20 @@ module Geocoder
         end
         args.map!{ |a| send(options[a]) }
 
-        if result = Geocoder.search(*args)
+        if (results = Geocoder.search(*args)).size > 0
 
           # execute custom block, if specified in configuration
           block_key = reverse ? :reverse_block : :geocode_block
           if custom_block = options[block_key]
-            custom_block.call(self, result)
+            custom_block.call(self, results)
 
           # else execute block passed directly to this method,
           # which generally performs the "auto-assigns"
           elsif block_given?
-            yield(self, result)
+            yield(self, results)
           end
         end
       end
-
-      ##
-      # Read the coordinates [lat,lon] of the object.
-      # Looks at user config to determine attributes.
-      #
-      def read_coordinates
-        [:latitude, :longitude].map{ |i| send self.class.geocoder_options[i] }
-      end
     end
   end
 end

data/lib/geocoder/request.rb

@@ -5,7 +5,7 @@ module Geocoder
 
     def location
       unless defined?(@location)
-        @location = Geocoder.search(ip)
+        @location = Geocoder.search(ip).first
       end
       @location
     end

data/lib/geocoder/results/base.rb

@@ -39,20 +39,6 @@ module Geocoder
       def country_code
         fail
       end
-
-      def [](i)
-        if i == 0
-          warn "DEPRECATION WARNING: You called '[0]' on a Geocoder::Result object. Geocoder.search(...) now returns a single result instead of an array so this is no longer necessary. This warning will be removed and an error will result in geocoder 1.0."
-        elsif i.is_a?(Fixnum)
-          warn "DEPRECATION WARNING: You tried to access a Geocoder result but Geocoder.search(...) now returns a single result instead of an array. This warning will be removed and an error will result in geocoder 1.0."
-        end
-        self
-      end
-
-      def first
-        warn "DEPRECATION WARNING: You called '.first' on a Geocoder::Result object. Geocoder.search(...) now returns a single result instead of an array so this is no longer necessary. This warning will be removed and an error will result in geocoder 1.0."
-        self
-      end
     end
   end
 end

data/lib/geocoder/results/geocoder_ca.rb

@@ -0,0 +1,58 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeocoderCa < Base
+
+    def coordinates
+      [@data['latt'].to_f, @data['longt'].to_f]
+    end
+
+    def address(format = :full)
+      "#{street_address}, #{city}, #{state} #{postal_code}, #{country}"
+    end
+
+    def street_address
+      "#{@data['stnumber']} #{@data['staddress']}"
+    end
+
+    def city
+      @data['city']
+    end
+
+    def state
+      @data['prov']
+    end
+
+    alias_method :province, :state
+
+    def postal_code
+      @data['postal']
+    end
+
+    def country
+      country_code == 'CA' ? 'Canada' : 'United States'
+    end
+
+    def country_code
+      prov = @data['prov']
+      return nil if prov.nil? || prov == ""
+      canadian_province_abbreviations.include?(@data['prov']) ? "CA" : "US"
+    end
+
+    def canadian_province_abbreviations
+      %w[ON QC NS NB MB BC PE SK AB NL]
+    end
+
+    def self.response_attributes
+      %w[latt longt inlatt inlongt betweenRoad1 betweenRoad2 distance
+        stnumber staddress city prov postal
+        NearRoad NearRoadDistance intersection major_intersection]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end