geocoder 1.1.3 → 1.1.4

data/lib/geocoder/results/mapquest.rb

@@ -1,66 +1,7 @@
 require 'geocoder/results/base'
+require 'geocoder/results/nominatim'
 
 module Geocoder::Result
-  class Mapquest < Base
-
-    def house_number
-      @data['address']['house_number']
-    end
-
-    def address
-      @data['display_name']
-    end
-
-    def street
-      @data['address']['road']
-    end
-
-    def city
-      @data['address']['city']
-    end
-
-    def village
-      @data['address']['villiage']
-    end
-
-    def town
-      @data['address']['town']
-    end
-
-    def state
-      @data['address']['state']
-    end
-
-    alias_method :state_code, :state
-
-    def postal_code
-      @data['address']['postcode']
-    end
-
-    def county
-      @data['address']['county']
-    end
-
-    def country
-      @data['address']['country']
-    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]
-    end
-
-    response_attributes.each do |a|
-      define_method a do
-        @data[a]
-      end
-    end
+  class Mapquest < Nominatim
   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,34 @@ 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
 
+    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|
-      define_method a do
-        @data[a]
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
       end
     end
   end

data/lib/geocoder/sql.rb

@@ -0,0 +1,104 @@
+module Geocoder
+  module Sql
+    extend self
+
+    ##
+    # Distance calculation for use with a database that supports POWER(),
+    # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
+    # ATAN2(), DEGREES(), and RADIANS().
+    #
+    # Based on the excellent tutorial at:
+    # 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)
+
+      "#{earth} * 2 * ASIN(SQRT(" +
+        "POWER(SIN((#{latitude.to_f} - #{lat_attr}) * PI() / 180 / 2), 2) + " +
+        "COS(#{latitude.to_f} * PI() / 180) * COS(#{lat_attr} * PI() / 180) * " +
+        "POWER(SIN((#{longitude.to_f} - #{lon_attr}) * PI() / 180 / 2), 2)" +
+      "))"
+    end
+
+    ##
+    # Distance calculation for use with a database without trigonometric
+    # functions, like SQLite. Approach is to find objects within a square
+    # rather than a circle, so results are very approximate (will include
+    # objects outside the given radius).
+    #
+    # Distance and bearing calculations are *extremely inaccurate*. To be
+    # clear: this only exists to provide interface consistency. Results
+    # 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)
+
+      # sin of 45 degrees = average x or y component of vector
+      factor = Math.sin(Math::PI / 4)
+
+      "(#{dy} * ABS(#{lat_attr} - #{latitude.to_f}) * #{factor}) + " +
+        "(#{dx} * ABS(#{lon_attr} - #{longitude.to_f}) * #{factor})"
+    end
+
+    def within_bounding_box(sw_lat, sw_lng, ne_lat, ne_lng, lat_attr, lon_attr)
+      spans = "#{lat_attr} BETWEEN #{sw_lat} AND #{ne_lat} AND "
+      # handle box that spans 180 longitude
+      if sw_lng.to_f > ne_lng.to_f
+        spans + "#{lon_attr} BETWEEN #{sw_lng} AND 180 OR " +
+        "#{lon_attr} BETWEEN -180 AND #{ne_lng}"
+      else
+        spans + "#{lon_attr} BETWEEN #{sw_lng} AND #{ne_lng}"
+      end
+    end
+
+    ##
+    # Fairly accurate bearing calculation. Takes a latitude, longitude,
+    # and an options hash which must include a :bearing value
+    # (:linear or :spherical).
+    #
+    # Based on:
+    # http://www.beginningspatial.com/calculating_bearing_one_point_another
+    #
+    def full_bearing(latitude, longitude, lat_attr, lon_attr, options = {})
+      case options[:bearing]
+      when :linear
+        "CAST(" +
+          "DEGREES(ATAN2( " +
+            "RADIANS(#{lon_attr} - #{longitude.to_f}), " +
+            "RADIANS(#{lat_attr} - #{latitude.to_f})" +
+          ")) + 360 " +
+        "AS decimal) % 360"
+      when :spherical
+        "CAST(" +
+          "DEGREES(ATAN2( " +
+            "SIN(RADIANS(#{lon_attr} - #{longitude.to_f})) * " +
+            "COS(RADIANS(#{lat_attr})), (" +
+              "COS(RADIANS(#{latitude.to_f})) * SIN(RADIANS(#{lat_attr}))" +
+            ") - (" +
+              "SIN(RADIANS(#{latitude.to_f})) * COS(RADIANS(#{lat_attr})) * " +
+              "COS(RADIANS(#{lon_attr} - #{longitude.to_f}))" +
+            ")" +
+          ")) + 360 " +
+        "AS decimal) % 360"
+      end
+    end
+
+    ##
+    # Totally lame bearing calculation. Basically useless except that it
+    # returns *something* in databases without trig functions.
+    #
+    def approx_bearing(latitude, longitude, lat_attr, lon_attr, options = {})
+      "CASE " +
+        "WHEN (#{lat_attr} >= #{latitude.to_f} AND " +
+          "#{lon_attr} >= #{longitude.to_f}) THEN  45.0 " +
+        "WHEN (#{lat_attr} <  #{latitude.to_f} AND " +
+          "#{lon_attr} >= #{longitude.to_f}) THEN 135.0 " +
+        "WHEN (#{lat_attr} <  #{latitude.to_f} AND " +
+          "#{lon_attr} <  #{longitude.to_f}) THEN 225.0 " +
+        "WHEN (#{lat_attr} >= #{latitude.to_f} AND " +
+          "#{lon_attr} <  #{longitude.to_f}) THEN 315.0 " +
+      "END"
+    end
+  end
+end

data/lib/geocoder/stores/active_record.rb

@@ -1,3 +1,4 @@
+require 'geocoder/sql'
 require 'geocoder/stores/base'
 
 ##
@@ -36,11 +37,13 @@ module Geocoder::Store
           if Geocoder::Calculations.coordinates_present?(latitude, longitude)
             near_scope_options(latitude, longitude, *args)
           else
-            where(false_condition) # no results if no lat/lon given
+            # 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:
+            # .order("distance")
+            select(select_clause(nil, "NULL", "NULL")).where(false_condition)
           end
         }
 
-
         ##
         # Find all objects within the area of a given bounding box.
         # Bounds must be an array of locations specifying the southwest
@@ -49,14 +52,15 @@ module Geocoder::Store
         #
         scope :within_bounding_box, lambda{ |bounds|
           sw_lat, sw_lng, ne_lat, ne_lng = bounds.flatten if bounds
-          return where(false_condition) unless sw_lat && sw_lng && ne_lat && ne_lng
-          spans = "#{geocoder_options[:latitude]} BETWEEN #{sw_lat} AND #{ne_lat} AND "
-          spans << if sw_lng > ne_lng   # Handle a box that spans 180
-            "#{geocoder_options[:longitude]} BETWEEN #{sw_lng} AND 180 OR #{geocoder_options[:longitude]} BETWEEN -180 AND #{ne_lng}"
+          if sw_lat && sw_lng && ne_lat && ne_lng
+            {:conditions => 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
-            "#{geocoder_options[:longitude]} BETWEEN #{sw_lng} AND #{ne_lng}"
+            select(select_clause(nil, "NULL", "NULL")).where(false_condition)
           end
-          { :conditions => spans }
         }
       end
     end
@@ -69,7 +73,7 @@ module Geocoder::Store
       def distance_from_sql(location, *args)
         latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
         if Geocoder::Calculations.coordinates_present?(latitude, longitude)
-          distance_from_sql_options(latitude, longitude, *args)
+          distance_sql(latitude, longitude, *args)
         end
       end
 
@@ -90,163 +94,87 @@ module Geocoder::Store
       #   set to false for no bearing calculation.
       #   See Geocoder::Configuration to know how configure default method.
       # * +:select+  - string with the SELECT SQL fragment (e.g. “id, name”)
-      # * +:order+   - column(s) for ORDER BY SQL clause; default is distance
+      # * +: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)
+        bearing = bearing_sql(latitude, longitude, options)
+        distance = distance_sql(latitude, longitude, options)
         if using_sqlite?
-          approx_near_scope_options(latitude, longitude, radius, options)
-        else
-          full_near_scope_options(latitude, longitude, radius, options)
-        end
-      end
-
-      def distance_from_sql_options(latitude, longitude, options = {})
-        if using_sqlite?
-          approx_distance_from_sql(latitude, longitude, options)
+          b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
+          args = b + [
+            full_column_name(geocoder_options[:latitude]),
+            full_column_name(geocoder_options[:longitude])
+          ]
+          conditions = Geocoder::Sql.within_bounding_box(*args)
         else
-          full_distance_from_sql(latitude, longitude, options)
+          conditions = ["#{distance} <= ?", radius]
         end
+        {
+          :select => select_clause(options[:select], distance, bearing),
+          :conditions => add_exclude_condition(conditions, options[:exclude]),
+          :order => options.include?(:order) ? options[:order] : "distance ASC"
+        }
       end
 
       ##
-      # Scope options hash for use with a database that supports POWER(),
-      # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
-      # ATAN2(), DEGREES(), and RADIANS().
+      # SQL for calculating distance based on the current database's
+      # capabilities (trig functions?).
       #
-      # 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]
-        options[:bearing] ||= (options[:method] ||
-                               geocoder_options[:method] ||
-                               Geocoder::Configuration.distances)
-        bearing = case options[:bearing]
-        when :linear
-          "CAST(" +
-            "DEGREES(ATAN2( " +
-              "RADIANS(#{full_column_name(lon_attr)} - #{longitude}), " +
-              "RADIANS(#{full_column_name(lat_attr)} - #{latitude})" +
-            ")) + 360 " +
-          "AS decimal) % 360"
-        when :spherical
-          "CAST(" +
-            "DEGREES(ATAN2( " +
-              "SIN(RADIANS(#{full_column_name(lon_attr)} - #{longitude})) * " +
-              "COS(RADIANS(#{full_column_name(lat_attr)})), (" +
-                "COS(RADIANS(#{latitude})) * SIN(RADIANS(#{full_column_name(lat_attr)}))" +
-              ") - (" +
-                "SIN(RADIANS(#{latitude})) * COS(RADIANS(#{full_column_name(lat_attr)})) * " +
-                "COS(RADIANS(#{full_column_name(lon_attr)} - #{longitude}))" +
-              ")" +
-            ")) + 360 " +
-          "AS decimal) % 360"
-        end
-        options[:units] ||= (geocoder_options[:units] || Geocoder::Configuration.units)
-        distance = full_distance_from_sql(latitude, longitude, options)
-        conditions = ["#{distance} <= ?", radius]
-        default_near_scope_options(latitude, longitude, radius, options).merge(
-          :select => "#{options[:select] || full_column_name("*")}, " +
-            "#{distance} AS distance" +
-            (bearing ? ", #{bearing} AS bearing" : ""),
-          :conditions => add_exclude_condition(conditions, options[:exclude])
+      def distance_sql(latitude, longitude, options = {})
+        method_prefix = using_sqlite? ? "approx" : "full"
+        Geocoder::Sql.send(
+          method_prefix + "_distance",
+          latitude, longitude,
+          full_column_name(geocoder_options[:latitude]),
+          full_column_name(geocoder_options[:longitude]),
+          options
         )
       end
 
-
-      # Distance calculations based on the excellent tutorial at:
-      # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
-
-      def full_distance_from_sql(latitude, longitude, options)
-        lat_attr = geocoder_options[:latitude]
-        lon_attr = geocoder_options[:longitude]
-
-        earth = Geocoder::Calculations.earth_radius(options[:units] || :mi)
-
-        "#{earth} * 2 * ASIN(SQRT(" +
-          "POWER(SIN((#{latitude} - #{full_column_name(lat_attr)}) * PI() / 180 / 2), 2) + " +
-          "COS(#{latitude} * PI() / 180) * COS(#{full_column_name(lat_attr)} * PI() / 180) * " +
-          "POWER(SIN((#{longitude} - #{full_column_name(lon_attr)}) * PI() / 180 / 2), 2) ))"
-      end
-
-      def approx_distance_from_sql(latitude, longitude, options)
-        lat_attr = geocoder_options[:latitude]
-        lon_attr = geocoder_options[:longitude]
-
-        dx = Geocoder::Calculations.longitude_degree_distance(30, options[:units] || :mi)
-        dy = Geocoder::Calculations.latitude_degree_distance(options[:units] || :mi)
-
-        # sin of 45 degrees = average x or y component of vector
-        factor = Math.sin(Math::PI / 4)
-
-        "(#{dy} * ABS(#{full_column_name(lat_attr)} - #{latitude}) * #{factor}) + " +
-          "(#{dx} * ABS(#{full_column_name(lon_attr)} - #{longitude}) * #{factor})"
-      end
-
       ##
-      # Scope options hash for use with a database without trigonometric
-      # functions, like SQLite. Approach is to find objects within a square
-      # rather than a circle, so results are very approximate (will include
-      # objects outside the given radius).
+      # SQL for calculating bearing based on the current database's
+      # capabilities (trig functions?).
       #
-      # 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]
-        unless options.include?(:bearing)
-          options[:bearing] = (options[:method] || \
-                               geocoder_options[:method] || \
-                               Geocoder::Configuration.distances)
+      def bearing_sql(latitude, longitude, options = {})
+        if !options.include?(:bearing)
+          options[:bearing] = Geocoder::Configuration.distances
         end
         if options[:bearing]
-          bearing = "CASE " +
-            "WHEN (#{full_column_name(lat_attr)} >= #{latitude} AND #{full_column_name(lon_attr)} >= #{longitude}) THEN  45.0 " +
-            "WHEN (#{full_column_name(lat_attr)} <  #{latitude} AND #{full_column_name(lon_attr)} >= #{longitude}) THEN 135.0 " +
-            "WHEN (#{full_column_name(lat_attr)} <  #{latitude} AND #{full_column_name(lon_attr)} <  #{longitude}) THEN 225.0 " +
-            "WHEN (#{full_column_name(lat_attr)} >= #{latitude} AND #{full_column_name(lon_attr)} <  #{longitude}) THEN 315.0 " +
-          "END"
-        else
-          bearing = false
+          method_prefix = using_sqlite? ? "approx" : "full"
+          Geocoder::Sql.send(
+            method_prefix + "_bearing",
+            latitude, longitude,
+            full_column_name(geocoder_options[:latitude]),
+            full_column_name(geocoder_options[:longitude]),
+            options
+          )
         end
-
-        options[:units] ||= (geocoder_options[:units] || Geocoder::Configuration.units)
-        distance = approx_distance_from_sql(latitude, longitude, options)
-
-        b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
-        conditions = [
-          "#{full_column_name(lat_attr)} BETWEEN ? AND ? AND #{full_column_name(lon_attr)} BETWEEN ? AND ?"] +
-          [b[0], b[2], b[1], b[3]
-        ]
-        default_near_scope_options(latitude, longitude, radius, options).merge(
-          :select => "#{options[:select] || full_column_name("*")}, " +
-            "#{distance} AS distance" +
-            (bearing ? ", #{bearing} AS bearing" : ""),
-          :conditions => add_exclude_condition(conditions, options[:exclude])
-        )
       end
 
       ##
-      # Options used for any near-like scope.
+      # Generate the SELECT clause.
       #
-      def default_near_scope_options(latitude, longitude, radius, options)
-        {
-          :order  => options[:order] || "distance",
-          :limit  => options[:limit],
-          :offset => options[:offset]
-        }
+      def select_clause(columns, distance, bearing = nil)
+        if columns == :geo_only
+          clause = ""
+        else
+          clause = (columns || full_column_name("*")) + ", "
+        end
+        clause + "#{distance} AS distance" +
+          (bearing ? ", #{bearing} AS bearing" : "")
       end
 
       ##
       # Adds a condition to exclude a given object by ID.
-      # The given conditions MUST be an array.
+      # Expects conditions as an array or string. Returns array.
       #
       def add_exclude_condition(conditions, exclude)
+        conditions = [conditions] if conditions.is_a?(String)
         if exclude
-          conditions[0] << " AND #{full_column_name(:id)} != ?"
+          conditions[0] << " AND #{full_column_name(primary_key)} != ?"
           conditions << exclude.id
         end
         conditions
@@ -280,8 +208,8 @@ module Geocoder::Store
       do_lookup(false) do |o,rs|
         if 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
+            o.__send__  "#{self.class.geocoder_options[:latitude]}=",  r.latitude
+            o.__send__  "#{self.class.geocoder_options[:longitude]}=", r.longitude
           end
           r.coordinates
         end
@@ -298,7 +226,7 @@ module Geocoder::Store
       do_lookup(true) do |o,rs|
         if r = rs.first
           unless r.address.nil?
-            o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
+            o.__send__ "#{self.class.geocoder_options[:fetched_address]}=", r.address
           end
           r.address
         end