geokit-rails 1.1.4 → 2.0.0.rc1

data/lib/geokit-rails/adapters/mysql2.rb

@@ -0,0 +1,22 @@
+module Geokit
+  module Adapters
+    class Mysql2 < Abstract
+      
+      def sphere_distance_sql(lat, lng, multiplier)
+        %|
+          (ACOS(least(1,COS(#{lat})*COS(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*COS(RADIANS(#{qualified_lng_column_name}))+
+          COS(#{lat})*SIN(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*SIN(RADIANS(#{qualified_lng_column_name}))+
+          SIN(#{lat})*SIN(RADIANS(#{qualified_lat_column_name}))))*#{multiplier})
+         |
+      end
+      
+      def flat_distance_sql(origin, lat_degree_units, lng_degree_units)
+        %|
+          SQRT(POW(#{lat_degree_units}*(#{origin.lat}-#{qualified_lat_column_name}),2)+
+          POW(#{lng_degree_units}*(#{origin.lng}-#{qualified_lng_column_name}),2))
+         |
+      end
+      
+    end
+  end
+end

data/lib/geokit-rails/adapters/sqlite.rb

@@ -0,0 +1,53 @@
+module Geokit
+  module Adapters
+    class SQLite < Abstract
+      
+      def self.add_numeric(name) 
+        @@connection.create_function name, 1, :numeric do |func, *args|
+          func.result = yield(*args)
+        end
+      end
+
+      def self.add_math(name)
+        add_numeric name do |*n|
+          Math.send name, *n
+        end
+      end
+      
+      class << self
+        def load(klass)
+          @@connection = klass.connection.raw_connection
+          # Define the functions needed
+          add_math 'sqrt'
+          add_math 'cos'
+          add_math 'acos'
+          add_math 'sin'
+
+          add_numeric('pow') { |n, m| n**m }
+          add_numeric('radians') { |n| n * Math::PI / 180 }
+          add_numeric('least') { |*args| args.min }
+        end
+      end
+      
+      def sphere_distance_sql(lat, lng, multiplier)
+        %|
+          (CASE WHEN #{qualified_lat_column_name} IS NULL OR #{qualified_lng_column_name} IS NULL THEN NULL ELSE
+          (ACOS(least(1,COS(#{lat})*COS(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*COS(RADIANS(#{qualified_lng_column_name}))+
+          COS(#{lat})*SIN(#{lng})*COS(RADIANS(#{qualified_lat_column_name}))*SIN(RADIANS(#{qualified_lng_column_name}))+
+          SIN(#{lat})*SIN(RADIANS(#{qualified_lat_column_name}))))*#{multiplier})
+          END)
+         |
+      end
+      
+      def flat_distance_sql(origin, lat_degree_units, lng_degree_units)
+        %|
+          (CASE WHEN #{qualified_lat_column_name} IS NULL OR #{qualified_lng_column_name} IS NULL THEN NULL ELSE
+          SQRT(POW(#{lat_degree_units}*(#{origin.lat}-#{qualified_lat_column_name}),2)+
+          POW(#{lng_degree_units}*(#{origin.lng}-#{qualified_lng_column_name}),2))
+          END)
+         |
+      end
+      
+    end
+  end
+end

data/lib/geokit-rails/core_extensions.rb

@@ -0,0 +1,10 @@
+# Extend Array with a sort_by_distance method.
+class Array
+  # This method creates a "distance" attribute on each object, calculates the
+  # distance from the passed origin, and finally sorts the array by the
+  # resulting distance.
+  def sort_by_distance_from(origin, opts={})
+    warn "[DEPRECATION] `Array#sort_by_distance_from(origin, opts)` is deprecated. Please use Array#sort_by{|e| e.distance_to(origin, opts)} instead which is not destructive"
+    self[0..-1] = sort_by{|e| e.distance_to(origin, opts)}
+  end
+end

data/lib/geokit-rails/defaults.rb

@@ -18,5 +18,4 @@ module Geokit
       end
     EOS
   end
-  Geokit::Geocoders.logger = ActiveRecord::Base.logger
 end

data/lib/geokit-rails/geocoder_control.rb

@@ -1,16 +1,18 @@
+require 'active_support/concern'
+
 module Geokit
   module GeocoderControl
+    extend ActiveSupport::Concern
+  
+    included do
+      if self.respond_to? :before_filter
+        self.send :before_filter, :set_geokit_domain
+      end
+    end
+    
     def set_geokit_domain
       Geokit::Geocoders::domain = request.domain
       logger.debug("Geokit is using the domain: #{Geokit::Geocoders::domain}")
     end
-  
-    def self.included(base)
-      if base.respond_to? :before_filter
-        base.send :before_filter, :set_geokit_domain
-      end
-    end
   end
-end
-
-ActionController::Base.send(:include, Geokit::GeocoderControl) if defined?(ActionController::Base)
+end

data/lib/geokit-rails/ip_geocode_lookup.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'active_support/concern'
 
 module Geokit 
   # Contains a class method geocode_ip_address which can be used to enable automatic geocoding
@@ -6,10 +7,7 @@ module Geokit
   # session to minimize web service calls.  The point of the helper is to enable location-based
   # websites to have a best-guess for new visitors.
   module IpGeocodeLookup
-    # Mix below class methods into ActionController.
-    def self.included(base) # :nodoc:
-      base.extend ClassMethods
-    end
+    extend ActiveSupport::Concern
     
     # Class method to mix into active record.
     module ClassMethods # :nodoc:

data/lib/geokit-rails/railtie.rb

@@ -0,0 +1,38 @@
+require 'geokit-rails'
+require 'rails'
+
+module Geokit
+
+  class Railtie < ::Rails::Railtie
+
+    config.geokit = ActiveSupport::OrderedOptions.new
+    config.geokit.geocoders = ActiveSupport::OrderedOptions.new
+
+    initializer 'geokit-rails.insert_into_active_record' do
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.send(:include, Geokit::ActsAsMappable::Glue)
+        Geokit::Geocoders.logger = ActiveRecord::Base.logger
+      end
+    end
+
+    initializer 'geokit-rails.insert_into_action_controller' do
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.send(:include, Geokit::GeocoderControl)
+        ActionController::Base.send(:include, GeoKit::IpGeocodeLookup)
+      end
+    end
+
+    config.after_initialize do |app|
+      options = app.config.geokit
+      geocoders_options = options.delete(:geocoders)
+
+      options.each do |k,v|
+        Geokit::send("#{k}=", v)
+      end
+      geocoders_options.each do |k,v|
+        Geokit::Geocoders::send("#{k}=", v)
+      end
+    end
+  end
+
+end

data/lib/geokit-rails/version.rb

@@ -0,0 +1,3 @@
+module GeokitRails
+  VERSION = "2.0.0.rc1"
+end

data/test/acts_as_mappable_test.rb

@@ -1,12 +1,11 @@
 require 'test_helper'
 
-
 Geokit::Geocoders::provider_order = [:google, :us]
 
 class ActsAsMappableTest < GeokitTestCase
-  
+
   LOCATION_A_IP = "217.10.83.5"
-  
+
   def setup
     @location_a = GeoKit::GeoLoc.new
     @location_a.lat = 32.918593
@@ -15,439 +14,396 @@ class ActsAsMappableTest < GeokitTestCase
     @location_a.state = "TX"
     @location_a.country_code = "US"
     @location_a.success = true
-    
+
     @sw = GeoKit::LatLng.new(32.91663,-96.982841)
     @ne = GeoKit::LatLng.new(32.96302,-96.919495)
     @bounds_center=GeoKit::LatLng.new((@sw.lat+@ne.lat)/2,(@sw.lng+@ne.lng)/2)
-    
+
     @starbucks = companies(:starbucks)
     @loc_a = locations(:a)
     @custom_loc_a = custom_locations(:a)
     @loc_e = locations(:e)
     @custom_loc_e = custom_locations(:e)
-  
+
     @barnes_and_noble = mock_organizations(:barnes_and_noble)
     @address = mock_addresses(:address_barnes_and_noble)
   end
-  
+
+  def test_sort_by_distance_from
+    locations = Location.all
+    unsorted = [locations(:a), locations(:b), locations(:c), locations(:d), locations(:e), locations(:f)]
+    sorted = [locations(:a), locations(:b), locations(:c), locations(:f), locations(:d), locations(:e)]
+    assert_equal unsorted, locations
+    assert_equal sorted, locations.sort_by{|l| l.distance_to(locations(:a))}
+    assert_equal sorted, locations.sort_by_distance_from(locations(:a))
+    assert_equal sorted, locations # last action desctructive
+  end
+
   def test_override_default_units_the_hard_way
     Location.default_units = :kms
-    locations = Location.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations.size   
-    locations = Location.count(:origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations
+    locations = Location.geo_scope(:origin => @loc_a).where("distance < 3.97")
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
     Location.default_units = :miles
   end
-  
+
   def test_include
-    locations = Location.find(:all, :origin => @loc_a, :include => :company, :conditions => "company_id = 1")
+    locations = Location.geo_scope(:origin => @loc_a).includes(:company).where("company_id = 1").all
     assert !locations.empty?
     assert_equal 1, locations[0].company.id
     assert_equal 'Starbucks', locations[0].company.name
   end
-  
+
   def test_distance_between_geocoded
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(@location_a)
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("San Francisco, CA").returns(@location_a)
-    assert_equal 0, Location.distance_between("Irving, TX", "San Francisco, CA") 
+    assert_equal 0, Location.distance_between("Irving, TX", "San Francisco, CA")
   end
-  
+
   def test_distance_to_geocoded
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(@location_a)
-    assert_equal 0, @custom_loc_a.distance_to("Irving, TX") 
+    assert_equal 0, @custom_loc_a.distance_to("Irving, TX")
   end
-  
+
   def test_distance_to_geocoded_error
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(GeoKit::GeoLoc.new)
     assert_raise(GeoKit::Geocoders::GeocodeError) { @custom_loc_a.distance_to("Irving, TX")  }
   end
-  
+
   def test_custom_attributes_distance_calculations
     assert_equal 0, @custom_loc_a.distance_to(@loc_a)
     assert_equal 0, CustomLocation.distance_between(@custom_loc_a, @loc_a)
   end
-  
+
   def test_distance_column_in_select
-    locations = Location.find(:all, :origin => @loc_a, :order => "distance ASC")
-    assert_equal 6, locations.size
+    locations = Location.geo_scope(:origin => @loc_a).order("distance ASC")
+    assert_equal 6, locations.all.size
     assert_equal 0, @loc_a.distance_to(locations.first)
     assert_in_delta 3.97, @loc_a.distance_to(locations.last, :units => :miles, :formula => :sphere), 0.01
   end
-  
+
   def test_find_with_distance_condition
-    locations = Location.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations.size
-    locations = Location.count(:origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 5, locations
-  end 
-  
+    locations = Location.geo_scope(:origin => @loc_a, :within => 3.97)
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
+  end
+
   def test_find_with_distance_condition_with_units_override
-    locations = Location.find(:all, :origin => @loc_a, :units => :kms, :conditions => "distance < 6.387")
-    assert_equal 5, locations.size
-    locations = Location.count(:origin => @loc_a, :units => :kms, :conditions => "distance < 6.387")
-    assert_equal 5, locations
+    locations = Location.geo_scope(:origin => @loc_a, :units => :kms, :within => 6.387)
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
+
   def test_find_with_distance_condition_with_formula_override
-    locations = Location.find(:all, :origin => @loc_a, :formula => :flat, :conditions => "distance < 6.387")
-    assert_equal 6, locations.size
-    locations = Location.count(:origin => @loc_a, :formula => :flat, :conditions => "distance < 6.387")
-    assert_equal 6, locations
+    locations = Location.geo_scope(:origin => @loc_a, :formula => :flat, :within => 6.387)
+    assert_equal 6, locations.all.size
+    assert_equal 6, locations.count
   end
-  
+
   def test_find_within
-    locations = Location.find_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations.size 
-    locations = Location.count_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations   
-  end
-  
-  def test_find_within_with_token
-    locations = Location.find(:all, :within => 3.97, :origin => @loc_a)
-    assert_equal 5, locations.size    
-    locations = Location.count(:within => 3.97, :origin => @loc_a)
-    assert_equal 5, locations
-  end
-  
+    locations = Location.within(3.97, :origin => @loc_a)
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
+  end
+
   def test_find_within_with_coordinates
-    locations = Location.find_within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
-    assert_equal 5, locations.size    
-    locations = Location.count_within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
-    assert_equal 5, locations
+    locations = Location.within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
+
   def test_find_with_compound_condition
-    locations = Location.find(:all, :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations
+    locations = Location.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_with_secure_compound_condition
-    locations = Location.find(:all, :origin => @loc_a, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations
+    locations = Location.geo_scope(:origin => @loc_a).where(["distance < ? and city = ?", 5, 'Coppell'])
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_beyond
-    locations = Location.find_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.size    
-    locations = Location.count_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations
+    locations = Location.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_beyond_with_token
-    locations = Location.find(:all, :beyond => 3.95, :origin => @loc_a)
-    assert_equal 1, locations.size    
-    locations = Location.count(:beyond => 3.95, :origin => @loc_a)
-    assert_equal 1, locations
+    # locations = Location.find(:all, :beyond => 3.95, :origin => @loc_a)
+    locations = Location.geo_scope(:beyond => 3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_beyond_with_coordinates
-    locations = Location.find_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations.size    
-    locations = Location.count_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations
+    locations = Location.beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_range_with_token
-    locations = Location.find(:all, :range => 0..10, :origin => @loc_a)
-    assert_equal 6, locations.size
-    locations = Location.count(:range => 0..10, :origin => @loc_a)
-    assert_equal 6, locations
+    locations = Location.geo_scope(:range => 0..10, :origin => @loc_a)
+    assert_equal 6, locations.all.size
+    assert_equal 6, locations.count
   end
-  
+
   def test_find_range_with_token_with_conditions
-    locations = Location.find(:all, :origin => @loc_a, :range => 0..10, :conditions => ["city = ?", 'Coppell'])
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :range => 0..10, :conditions => ["city = ?", 'Coppell'])
-    assert_equal 2, locations
+    locations = Location.geo_scope(:origin => @loc_a, :range => 0..10).where(["city = ?", 'Coppell'])
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_range_with_token_with_hash_conditions
-    locations = Location.find(:all, :origin => @loc_a, :range => 0..10, :conditions => {:city => 'Coppell'})
-    assert_equal 2, locations.size
-    locations = Location.count(:origin => @loc_a, :range => 0..10, :conditions => {:city => 'Coppell'})
-    assert_equal 2, locations
+    locations = Location.geo_scope(:origin => @loc_a, :range => 0..10).where(:city => 'Coppell')
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_range_with_token_excluding_end
-    locations = Location.find(:all, :range => 0...10, :origin => @loc_a)
-    assert_equal 6, locations.size
-    locations = Location.count(:range => 0...10, :origin => @loc_a)
-    assert_equal 6, locations
+    locations = Location.geo_scope(:range => 0...10, :origin => @loc_a)
+    assert_equal 6, locations.all.size
+    assert_equal 6, locations.count
   end
-  
+
   def test_find_nearest
-    assert_equal @loc_a, Location.find_nearest(:origin => @loc_a)
+    assert_equal @loc_a, Location.nearest(:origin => @loc_a).first
   end
-  
-  def test_find_nearest_through_find
-     assert_equal @loc_a, Location.find(:nearest, :origin => @loc_a)
-  end
-  
+
   def test_find_nearest_with_coordinates
-    assert_equal @loc_a, Location.find_nearest(:origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal @loc_a, Location.nearest(:origin =>[@loc_a.lat, @loc_a.lng]).first
   end
-  
+
   def test_find_farthest
-    assert_equal @loc_e, Location.find_farthest(:origin => @loc_a)
-  end
-  
-  def test_find_farthest_through_find
-    assert_equal @loc_e, Location.find(:farthest, :origin => @loc_a)
+    assert_equal @loc_e, Location.farthest(:origin => @loc_a).first
   end
-  
+
   def test_find_farthest_with_coordinates
-    assert_equal @loc_e, Location.find_farthest(:origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal @loc_e, Location.farthest(:origin =>[@loc_a.lat, @loc_a.lng]).first
   end
-  
+
   def test_scoped_distance_column_in_select
-    locations = @starbucks.locations.find(:all, :origin => @loc_a, :order => "distance ASC")
-    assert_equal 5, locations.size
+    locations = @starbucks.locations.geo_scope(:origin => @loc_a).order("distance ASC")
+    assert_equal 5, locations.all.size
     assert_equal 0, @loc_a.distance_to(locations.first)
     assert_in_delta 3.97, @loc_a.distance_to(locations.last, :units => :miles, :formula => :sphere), 0.01
   end
-  
+
   def test_scoped_find_with_distance_condition
-    locations = @starbucks.locations.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 4, locations.size
-    locations = @starbucks.locations.count(:origin => @loc_a, :conditions => "distance < 3.97")
-    assert_equal 4, locations
-  end 
-  
+    locations = @starbucks.locations.geo_scope(:origin => @loc_a).where("distance < 3.97")
+    assert_equal 4, locations.all.size
+    assert_equal 4, locations.count
+  end
+
   def test_scoped_find_within
-    locations = @starbucks.locations.find_within(3.97, :origin => @loc_a)
-    assert_equal 4, locations.size    
-    locations = @starbucks.locations.count_within(3.97, :origin => @loc_a)
-    assert_equal 4, locations
+    locations = @starbucks.locations.within(3.97, :origin => @loc_a)
+    assert_equal 4, locations.all.size
+    assert_equal 4, locations.count
   end
-  
+
   def test_scoped_find_with_compound_condition
-    locations = @starbucks.locations.find(:all, :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.size
-    locations = @starbucks.locations.count( :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations
+    locations = @starbucks.locations.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_scoped_find_beyond
-    locations = @starbucks.locations.find_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.size 
-    locations = @starbucks.locations.count_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations   
+    locations = @starbucks.locations.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_scoped_find_nearest
-    assert_equal @loc_a, @starbucks.locations.find_nearest(:origin => @loc_a)
+    assert_equal @loc_a, @starbucks.locations.nearest(:origin => @loc_a).first
   end
-  
+
   def test_scoped_find_farthest
-    assert_equal @loc_e, @starbucks.locations.find_farthest(:origin => @loc_a)
-  end  
-  
+    assert_equal @loc_e, @starbucks.locations.farthest(:origin => @loc_a).first
+  end
+
   def test_ip_geocoded_distance_column_in_select
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :order => "distance ASC")
-    assert_equal 6, locations.size
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).order("distance ASC")
+    assert_equal 6, locations.all.size
     assert_equal 0, @loc_a.distance_to(locations.first)
     assert_in_delta 3.97, @loc_a.distance_to(locations.last, :units => :miles, :formula => :sphere), 0.01
   end
-  
+
   def test_ip_geocoded_find_with_distance_condition
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :conditions => "distance < 3.97")
-    assert_equal 5, locations.size
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count(:origin => LOCATION_A_IP, :conditions => "distance < 3.97")
-    assert_equal 5, locations
-  end 
-  
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).where("distance < 3.97")
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
+  end
+
   def test_ip_geocoded_find_within
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find_within(3.97, :origin => LOCATION_A_IP)
-    assert_equal 5, locations.size    
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count_within(3.97, :origin => LOCATION_A_IP)
-    assert_equal 5, locations
+    locations = Location.within(3.97, :origin => LOCATION_A_IP)
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
+
   def test_ip_geocoded_find_with_compound_condition
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.size
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count(:origin => LOCATION_A_IP, :conditions => "distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).where("distance < 5 and city = 'Coppell'")
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_ip_geocoded_find_with_secure_compound_condition
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find(:all, :origin => LOCATION_A_IP, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.size
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count(:origin => LOCATION_A_IP, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).where(["distance < ? and city = ?", 5, 'Coppell'])
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_ip_geocoded_find_beyond
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.find_beyond(3.95, :origin => LOCATION_A_IP)
-    assert_equal 1, locations.size    
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.count_beyond(3.95, :origin => LOCATION_A_IP)
-    assert_equal 1, locations
+    locations = Location.beyond(3.95, :origin => LOCATION_A_IP)
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_ip_geocoded_find_nearest
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    assert_equal @loc_a, Location.find_nearest(:origin => LOCATION_A_IP)
+    assert_equal @loc_a, Location.nearest(:origin => LOCATION_A_IP).first
   end
-  
+
   def test_ip_geocoded_find_farthest
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    assert_equal @loc_e, Location.find_farthest(:origin => LOCATION_A_IP)
+    assert_equal @loc_e, Location.farthest(:origin => LOCATION_A_IP).first
   end
-  
+
   def test_ip_geocoder_exception
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with('127.0.0.1').returns(GeoKit::GeoLoc.new)
     assert_raises GeoKit::Geocoders::GeocodeError do
-      Location.find_farthest(:origin => '127.0.0.1')
+      Location.farthest(:origin => '127.0.0.1').first
     end
   end
-  
+
   def test_address_geocode
-    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with('Irving, TX').returns(@location_a)  
-    locations = Location.find(:all, :origin => 'Irving, TX', :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.size
+    GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with('Irving, TX').returns(@location_a)
+    locations = Location.geo_scope(:origin => 'Irving, TX').where(["distance < ? and city = ?", 5, 'Coppell'])
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_with_custom_distance_condition
-    locations = CustomLocation.find(:all, :origin => @loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations.size 
-    locations = CustomLocation.count(:origin => @loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations
-  end  
-  
+    locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 3.97")
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
+  end
+
   def test_find_with_custom_distance_condition_using_custom_origin
-    locations = CustomLocation.find(:all, :origin => @custom_loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations.size 
-    locations = CustomLocation.count(:origin => @custom_loc_a, :conditions => "dist < 3.97")
-    assert_equal 5, locations
+    locations = CustomLocation.geo_scope(:origin => @custom_loc_a).where("dist < 3.97")
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
+
   def test_find_within_with_custom
-    locations = CustomLocation.find_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations.size    
-    locations = CustomLocation.count_within(3.97, :origin => @loc_a)
-    assert_equal 5, locations
+    locations = CustomLocation.within(3.97, :origin => @loc_a)
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
+
   def test_find_within_with_coordinates_with_custom
-    locations = CustomLocation.find_within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 5, locations.size    
-    locations = CustomLocation.count_within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 5, locations
+    locations = CustomLocation.within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
+
   def test_find_with_compound_condition_with_custom
-    locations = CustomLocation.find(:all, :origin => @loc_a, :conditions => "dist < 5 and city = 'Coppell'")
-    assert_equal 1, locations.size
-    locations = CustomLocation.count(:origin => @loc_a, :conditions => "dist < 5 and city = 'Coppell'")
-    assert_equal 1, locations
+    locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 5 and city = 'Coppell'")
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_with_secure_compound_condition_with_custom
-    locations = CustomLocation.find(:all, :origin => @loc_a, :conditions => ["dist < ? and city = ?", 5, 'Coppell'])
-    assert_equal 1, locations.size
-    locations = CustomLocation.count(:origin => @loc_a, :conditions => ["dist < ? and city = ?", 5, 'Coppell'])
-    assert_equal 1, locations
+    locations = CustomLocation.geo_scope(:origin => @loc_a).where(["dist < ? and city = ?", 5, 'Coppell'])
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_beyond_with_custom
-    locations = CustomLocation.find_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.size  
-    locations = CustomLocation.count_beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations  
+    locations = CustomLocation.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_beyond_with_coordinates_with_custom
-    locations = CustomLocation.find_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations.size    
-    locations = CustomLocation.count_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations
+    locations = CustomLocation.beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal 1, locations.all.size
+    assert_equal 1, locations.count
   end
-  
+
   def test_find_nearest_with_custom
-    assert_equal @custom_loc_a, CustomLocation.find_nearest(:origin => @loc_a)
+    assert_equal @custom_loc_a, CustomLocation.nearest(:origin => @loc_a).first
   end
-  
+
   def test_find_nearest_with_coordinates_with_custom
-    assert_equal @custom_loc_a, CustomLocation.find_nearest(:origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal @custom_loc_a, CustomLocation.nearest(:origin =>[@loc_a.lat, @loc_a.lng]).first
   end
-  
+
   def test_find_farthest_with_custom
-    assert_equal @custom_loc_e, CustomLocation.find_farthest(:origin => @loc_a)
+    assert_equal @custom_loc_e, CustomLocation.farthest(:origin => @loc_a).first
   end
-  
+
   def test_find_farthest_with_coordinates_with_custom
-    assert_equal @custom_loc_e, CustomLocation.find_farthest(:origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal @custom_loc_e, CustomLocation.farthest(:origin =>[@loc_a.lat, @loc_a.lng]).first
   end
-  
+
   def test_find_with_array_origin
-    locations = Location.find(:all, :origin =>[@loc_a.lat,@loc_a.lng], :conditions => "distance < 3.97")
-    assert_equal 5, locations.size
-    locations = Location.count(:origin =>[@loc_a.lat,@loc_a.lng], :conditions => "distance < 3.97")
-    assert_equal 5, locations
+    locations = Location.geo_scope(:origin =>[@loc_a.lat,@loc_a.lng]).where("distance < 3.97")
+    assert_equal 5, locations.all.size
+    assert_equal 5, locations.count
   end
-  
-  
+
+
   # Bounding box tests
-  
+
   def test_find_within_bounds
-    locations = Location.find_within_bounds([@sw,@ne])
-    assert_equal 2, locations.size
-    locations = Location.count_within_bounds([@sw,@ne])
-    assert_equal 2, locations
+    locations = Location.in_bounds([@sw,@ne])
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_within_bounds_ordered_by_distance
-    locations = Location.find_within_bounds([@sw,@ne], :origin=>@bounds_center, :order=>'distance asc')
+    locations = Location.in_bounds([@sw,@ne], :origin=>@bounds_center).order('distance asc')
     assert_equal locations[0], locations(:d)
     assert_equal locations[1], locations(:a)
   end
-  
+
   def test_find_within_bounds_with_token
-    locations = Location.find(:all, :bounds=>[@sw,@ne])
-    assert_equal 2, locations.size
-    locations = Location.count(:bounds=>[@sw,@ne])
-    assert_equal 2, locations  
+    locations = Location.geo_scope(:bounds=>[@sw,@ne])
+    assert_equal 2, locations.all.size
+    assert_equal 2, locations.count
   end
-  
+
   def test_find_within_bounds_with_string_conditions
-    locations = Location.find(:all, :bounds=>[@sw,@ne], :conditions=>"id !=#{locations(:a).id}")
-    assert_equal 1, locations.size
+    locations = Location.geo_scope(:bounds=>[@sw,@ne]).where("id !=#{locations(:a).id}")
+    assert_equal 1, locations.all.size
   end
-  
+
   def test_find_within_bounds_with_array_conditions
-    locations = Location.find(:all, :bounds=>[@sw,@ne], :conditions=>["id != ?", locations(:a).id])
-    assert_equal 1, locations.size
+    locations = Location.geo_scope(:bounds=>[@sw,@ne]).where(["id != ?", locations(:a).id])
+    assert_equal 1, locations.all.size
   end
-  
+
   def test_find_within_bounds_with_hash_conditions
-    locations = Location.find(:all, :bounds=>[@sw,@ne], :conditions=>{:id => locations(:a).id})
-    assert_equal 1, locations.size
+    locations = Location.geo_scope(:bounds=>[@sw,@ne]).where({:id => locations(:a).id})
+    assert_equal 1, locations.all.size
   end
-  
+
   def test_auto_geocode
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("Irving, TX").returns(@location_a)
     store=Store.new(:address=>'Irving, TX')
     store.save
-    assert_equal store.lat,@location_a.lat  
+    assert_equal store.lat,@location_a.lat
     assert_equal store.lng,@location_a.lng
     assert_equal 0, store.errors.size
   end
-  
+
   def test_auto_geocode_failure
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with("BOGUS").returns(GeoKit::GeoLoc.new)
     store=Store.new(:address=>'BOGUS')
@@ -455,20 +411,19 @@ class ActsAsMappableTest < GeokitTestCase
     assert store.new_record?
     assert_equal 1, store.errors.size
   end
-  
+
   # Test :through
-    
+
   def test_find_with_through
-    organizations = MockOrganization.find(:all, :origin => @location_a, :order => 'distance ASC')
-    assert_equal 2, organizations.size
-    organizations = MockOrganization.count(:origin => @location_a, :conditions => "distance < 3.97")
-    assert_equal 1, organizations
+    organizations = MockOrganization.geo_scope(:origin => @location_a).order('distance ASC')
+    assert_equal 2, organizations.all.size
+    organizations = MockOrganization.geo_scope(:origin => @location_a).where("distance < 3.97")
+    assert_equal 1, organizations.count
   end
-  
+
   def test_find_with_through_with_hash
-    people = MockPerson.find(:all, :origin => @location_a, :order => 'distance ASC')
+    people = MockPerson.geo_scope(:origin => @location_a).order('distance ASC')
     assert_equal 2, people.size
-    people = MockPerson.count(:origin => @location_a, :conditions => "distance < 3.97")
-    assert_equal 2, people
-  end 
+    assert_equal 2, people.count
+  end
 end