geocoder 0.9.11 → 0.9.12

data/lib/geocoder/lookups/base.rb

@@ -20,9 +20,23 @@ module Geocoder
       # "205.128.54.202") for geocoding, or coordinates (latitude, longitude)
       # for reverse geocoding. Returns an array of <tt>Geocoder::Result</tt>s.
       #
-      def search(*args)
-        reverse = (args.size == 2) || coordinates?(args.first)
-        results(args.join(","), reverse).map{ |r| result_class.new(r) }
+      def search(query, *args)
+        # convert coordinates as separate arguments to an array
+        if query.is_a?(Numeric) and args.first.is_a?(Numeric)
+          warn "DEPRECATION WARNING: Instead of passing latitude/longitude as separate arguments to the search method, please pass an array: [#{query},#{args.first}]. The old argument format will not be supported in Geocoder v.1.0."
+          query = [query, args.first]
+        end
+
+        # if coordinates given as string, turn into array
+        query = query.split(/\s*,\s*/) if coordinates?(query)
+
+        if query.is_a?(Array)
+          reverse = true
+          query = query.join(',')
+        else
+          reverse = false
+        end
+        results(query, reverse).map{ |r| result_class.new(r) }
       end
 
 
@@ -113,14 +127,14 @@ module Geocoder
       # Is the given string a loopback IP address?
       #
       def loopback_address?(ip)
-        !!(ip == "0.0.0.0" or ip.match(/^127/))
+        !!(ip == "0.0.0.0" or ip.to_s.match(/^127/))
       end
 
       ##
       # Does the given string look like latitude/longitude coordinates?
       #
       def coordinates?(value)
-        !!value.to_s.match(/^[0-9\.\-]+, ?[0-9\.\-]+$/)
+        !!value.to_s.match(/^[0-9\.\-]+, *[0-9\.\-]+$/)
       end
 
       ##

data/lib/geocoder/models/active_record.rb

@@ -0,0 +1,41 @@
+require 'geocoder/models/base'
+
+module Geocoder
+  module Model
+    module ActiveRecord
+      include Base
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def geocoded_by(address_attr, options = {}, &block)
+        geocoder_init(
+          :geocode       => true,
+          :user_address  => address_attr,
+          :latitude      => options[:latitude]  || :latitude,
+          :longitude     => options[:longitude] || :longitude,
+          :geocode_block => block
+        )
+      end
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def reverse_geocoded_by(latitude_attr, longitude_attr, options = {}, &block)
+        geocoder_init(
+          :reverse_geocode => true,
+          :fetched_address => options[:address] || :address,
+          :latitude        => latitude_attr,
+          :longitude       => longitude_attr,
+          :reverse_block   => block
+        )
+      end
+
+
+      private # --------------------------------------------------------------
+
+      def geocoder_file_name;   "active_record"; end
+      def geocoder_module_name; "ActiveRecord"; end
+    end
+  end
+end

data/lib/geocoder/models/base.rb

@@ -0,0 +1,44 @@
+require 'geocoder'
+
+module Geocoder
+
+  ##
+  # Methods for invoking Geocoder in a model.
+  #
+  module Model
+    module Base
+
+      def geocoder_options
+        @geocoder_options
+      end
+
+      def geocoded_by
+        fail
+      end
+
+      def reverse_geocoded_by
+        fail
+      end
+
+
+      private # ----------------------------------------------------------------
+
+      def geocoder_init(options)
+        unless geocoder_initialized?
+          @geocoder_options = {}
+          require "geocoder/stores/#{geocoder_file_name}"
+          include eval("Geocoder::Store::" + geocoder_module_name)
+        end
+        @geocoder_options.merge! options
+      end
+
+      def geocoder_initialized?
+        begin
+          included_modules.include? eval("Geocoder::Store::" + geocoder_module_name)
+        rescue NameError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/models/mongoid.rb

@@ -0,0 +1,47 @@
+require 'geocoder/models/base'
+
+module Geocoder
+  module Model
+    module Mongoid
+      include Base
+
+      def self.included(base); base.extend(self); end
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def geocoded_by(address_attr, options = {}, &block)
+        geocoder_init(
+          :geocode       => true,
+          :user_address  => address_attr,
+          :coordinates   => options[:coordinates] || :coordinates,
+          :geocode_block => block
+        )
+      end
+
+      ##
+      # Set attribute names and include the Geocoder module.
+      #
+      def reverse_geocoded_by(coordinates_attr, options = {}, &block)
+        geocoder_init(
+          :reverse_geocode => true,
+          :fetched_address => options[:address] || :address,
+          :coordinates     => coordinates_attr,
+          :reverse_block   => block
+        )
+      end
+
+
+      private # --------------------------------------------------------------
+
+      def geocoder_file_name;   "mongoid"; end
+      def geocoder_module_name; "Mongoid"; end
+
+      def geocoder_init(options)
+        super(options)
+        index [[ geocoder_options[:coordinates], Mongo::GEO2D ]],
+          :min => -180, :max => 180 # create 2d index
+      end
+    end
+  end
+end

data/lib/geocoder/railtie.rb

@@ -1,4 +1,5 @@
 require 'geocoder'
+require 'geocoder/models/active_record'
 
 module Geocoder
   if defined? Rails::Railtie
@@ -17,63 +18,8 @@ module Geocoder
 
   class Railtie
     def self.insert
-      return unless defined?(::ActiveRecord)
-      ::ActiveRecord::Base.extend(ModelMethods)
-    end
-  end
-
-  ##
-  # Methods available in the model class before Geocoder is invoked.
-  #
-  module ModelMethods
-
-    ##
-    # Set attribute names and include the Geocoder module.
-    #
-    def geocoded_by(address_attr, options = {}, &block)
-      geocoder_init(
-        :geocode       => true,
-        :user_address  => address_attr,
-        :latitude      => options[:latitude]  || :latitude,
-        :longitude     => options[:longitude] || :longitude,
-        :geocode_block => block
-      )
-    end
-
-    ##
-    # Set attribute names and include the Geocoder module.
-    #
-    def reverse_geocoded_by(latitude_attr, longitude_attr, options = {}, &block)
-      geocoder_init(
-        :reverse_geocode => true,
-        :fetched_address => options[:address] || :address,
-        :latitude        => latitude_attr,
-        :longitude       => longitude_attr,
-        :reverse_block   => block
-      )
-    end
-
-    def geocoder_options
-      @geocoder_options
-    end
-
-
-    private # ----------------------------------------------------------------
-
-    def geocoder_init(options)
-      unless geocoder_initialized?
-        @geocoder_options = {}
-        require 'geocoder/orms/active_record'
-        include Geocoder::Orm::ActiveRecord
-      end
-      @geocoder_options.merge! options
-    end
-
-    def geocoder_initialized?
-      begin
-        included_modules.include? Geocoder::Orm::ActiveRecord
-      rescue NameError
-        false
+      if defined?(::ActiveRecord)
+        ::ActiveRecord::Base.extend(Model::ActiveRecord)
       end
     end
   end

data/lib/geocoder/{orms → stores}/active_record.rb

@@ -1,10 +1,10 @@
-require 'geocoder/orms/base'
-require 'geocoder/orms/active_record_legacy'
+require 'geocoder/stores/base'
+require 'geocoder/stores/active_record_legacy'
 
 ##
 # Add geocoding functionality to any ActiveRecord object.
 #
-module Geocoder::Orm
+module Geocoder::Store
   module ActiveRecord
     include Base
     include ActiveRecord::Legacy
@@ -34,8 +34,7 @@ module Geocoder::Orm
         # for details).
         #
         scope :near, lambda{ |location, *args|
-          latitude, longitude = location.is_a?(Array) ?
-            location : Geocoder.coordinates(location)
+          latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
           if latitude and longitude
             near_scope_options(latitude, longitude, *args)
           else
@@ -50,6 +49,8 @@ module Geocoder::Orm
     #
     module ClassMethods
 
+      private # ----------------------------------------------------------------
+
       ##
       # Get options hash suitable for passing to ActiveRecord.find to get
       # records within a radius (in miles) of the given point.
@@ -63,9 +64,7 @@ module Geocoder::Orm
       #   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)
+      # * +:order+   - column(s) for ORDER BY SQL clause; default is distance
       # * +:exclude+ - an object to exclude (used by the +nearbys+ method)
       #
       def near_scope_options(latitude, longitude, radius = 20, options = {})
@@ -77,9 +76,6 @@ module Geocoder::Orm
         end
       end
 
-
-      private # ----------------------------------------------------------------
-
       ##
       # Scope options hash for use with a database that supports POWER(),
       # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
@@ -157,12 +153,16 @@ module Geocoder::Orm
         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)"
+        # sin of 45 degrees = average x or y component of vector
+        factor = Math.sin(Math::PI / 4)
+
+        distance = "(#{dy} * ABS(#{lat_attr} - #{latitude}) * #{factor}) + " +
+          "(#{dx} * ABS(#{lon_attr} - #{longitude}) * #{factor})"
         default_near_scope_options(latitude, longitude, radius, options).merge(
           :select => "#{options[:select] || '*'}, " +
             "#{distance} AS distance" +
-            (bearing ? ", #{bearing} AS bearing" : "")
+            (bearing ? ", #{bearing} AS bearing" : ""),
+          :order => distance
         )
       end
 
@@ -172,7 +172,7 @@ 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)
+        b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
         conditions = \
           ["#{lat_attr} BETWEEN ? AND ? AND #{lon_attr} BETWEEN ? AND ?"] +
           [b[0], b[2], b[1], b[3]]
@@ -180,6 +180,9 @@ module Geocoder::Orm
           conditions[0] << " AND #{table_name}.id != ?"
           conditions << obj.id
         end
+        if options[:limit] || options[:offset]
+          warn "DEPRECATION WARNING: The :limit and :offset options to Geocoder's 'near' method are deprecated and will be removed in Geocoder v1.0. Please specify these options using ARel relations instead, for example: Place.near(...).limit(10).offset(20)."
+        end
         {
           :group  => columns.map{ |c| "#{table_name}.#{c.name}" }.join(','),
           :order  => options[:order],

data/lib/geocoder/{orms → stores}/active_record_legacy.rb

@@ -1,4 +1,4 @@
-module Geocoder::Orm::ActiveRecord
+module Geocoder::Store::ActiveRecord
   module Legacy
 
     ##

data/lib/geocoder/{orms → stores}/base.rb

@@ -1,5 +1,5 @@
 module Geocoder
-  module Orm
+  module Store
     module Base
 
       ##
@@ -18,17 +18,44 @@ module Geocoder
 
       ##
       # Calculate the distance from the object to an arbitrary point.
-      # Takes two floats (latitude, longitude) and a symbol specifying the
-      # units to be used (:mi or :km; default is :mi).
+      # See Geocoder::Calculations.distance_between for ways of specifying
+      # the point. Also takes a symbol specifying the units
+      # (:mi or :km; default is :mi).
       #
-      def distance_to(lat, lon, units = :mi)
+      def distance_to(point, *args)
+        if point.is_a?(Numeric) and args[0].is_a?(Numeric)
+          warn "DEPRECATION WARNING: Instead of passing latitude/longitude as separate arguments to the distance_to/from method, please pass an array [#{point},#{args[0]}], a geocoded object, or a geocodable address (string). The old argument format will not be supported in Geocoder v.1.0."
+          point = [point, args.shift]
+        end
         return nil unless geocoded?
-        mylat,mylon = to_coordinates
-        Geocoder::Calculations.distance_between(mylat, mylon, lat, lon, :units => units)
+        Geocoder::Calculations.distance_between(
+          to_coordinates, point, :units => args.pop || :mi)
       end
 
       alias_method :distance_from, :distance_to
 
+      ##
+      # Calculate the bearing from the object to another point.
+      # See Geocoder::Calculations.distance_between for
+      # ways of specifying the point.
+      #
+      def bearing_to(point, options = {})
+        return nil unless geocoded?
+        Geocoder::Calculations.bearing_between(
+          to_coordinates, point, options)
+      end
+
+      ##
+      # Calculate the bearing from another point to the object.
+      # See Geocoder::Calculations.distance_between for
+      # ways of specifying the point.
+      #
+      def bearing_from(point, options = {})
+        return nil unless geocoded?
+        Geocoder::Calculations.bearing_between(
+          point, to_coordinates, options)
+      end
+
       ##
       # Get nearby geocoded objects.
       # Takes the same options hash as the near class method (scope).
@@ -40,7 +67,7 @@ module Geocoder
           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)
+        self.class.near(self, radius, options)
       end
 
       ##
@@ -72,15 +99,14 @@ module Geocoder
       def do_lookup(reverse = false)
         options = self.class.geocoder_options
         if reverse and options[:reverse_geocode]
-          args = [:latitude, :longitude]
+          query = to_coordinates
         elsif !reverse and options[:geocode]
-          args = [:user_address]
+          query = send(options[:user_address])
         else
           return
         end
-        args.map!{ |a| send(options[a]) }
 
-        if (results = Geocoder.search(*args)).size > 0
+        if (results = Geocoder.search(query)).size > 0
 
           # execute custom block, if specified in configuration
           block_key = reverse ? :reverse_block : :geocode_block

data/lib/geocoder/stores/mongoid.rb

@@ -0,0 +1,73 @@
+require 'geocoder/stores/base'
+
+module Geocoder::Store
+  module Mongoid
+    include Base
+
+    def self.included(base)
+      base.class_eval do
+
+        scope :geocoded, lambda {
+          where(geocoder_options[:coordinates].ne => nil)
+        }
+
+        scope :not_geocoded, lambda {
+          where(geocoder_options[:coordinates] => nil)
+        }
+
+        scope :near, lambda{ |location, *args|
+          coords  = Geocoder::Calculations.extract_coordinates(location)
+          radius  = args.size > 0 ? args.shift : 20
+          options = args.size > 0 ? args.shift : {}
+          conds   = {:coordinates => {
+            "$nearSphere" => coords.reverse,
+            "$maxDistance" => Geocoder::Calculations.distance_to_radians(
+              radius, options[:units] || :mi)
+          }}
+          if obj = options[:exclude]
+            conds[:_id.ne] = obj.id
+          end
+          criteria.where(conds)
+        }
+      end
+    end
+
+    ##
+    # Coordinates [lat,lon] of the object.
+    # This method always returns coordinates in lat,lon order,
+    # even though internally they are stored in the opposite order.
+    #
+    def to_coordinates
+      coords = send(self.class.geocoder_options[:coordinates])
+      coords.is_a?(Array) ? coords.reverse : []
+    end
+
+    ##
+    # Look up coordinates and assign to +latitude+ and +longitude+ attributes
+    # (or other as specified in +geocoded_by+). Returns coordinates (array).
+    #
+    def geocode
+      do_lookup(false) do |o,rs|
+        r = rs.first
+        unless r.coordinates.nil?
+          o.send :write_attribute, self.class.geocoder_options[:coordinates], r.coordinates.reverse
+        end
+        r.coordinates
+      end
+    end
+
+    ##
+    # Look up address and assign to +address+ attribute (or other as specified
+    # in +reverse_geocoded_by+). Returns address (string).
+    #
+    def reverse_geocode
+      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
+        r.address
+      end
+    end
+  end
+end