geokit-rails3 0.1.0 → 0.1.1

data/lib/geokit-rails3/acts_as_mappable.rb

@@ -3,22 +3,22 @@ require 'active_support/concern'
 
 module Geokit
   module ActsAsMappable
-    
+
     class UnsupportedAdapter < StandardError ; end
-    
+
     # Add the +acts_as_mappable+ method into ActiveRecord subclasses
     module Glue # :nodoc:
       extend ActiveSupport::Concern
-      
+
       module ClassMethods # :nodoc:
         def acts_as_mappable(options = {})
           metaclass = (class << self; self; end)
-        
+
           self.send :include, Geokit::ActsAsMappable
-          
+
           cattr_accessor :through
           self.through = options[:through]
-        
+
           if reflection = Geokit::ActsAsMappable.end_of_reflection_chain(self.through, self)
             metaclass.instance_eval do
               [ :distance_column_name, :default_units, :default_formula, :lat_column_name, :lng_column_name, :qualified_lat_column_name, :qualified_lng_column_name ].each do |method_name|
@@ -29,7 +29,7 @@ module Geokit
             end
           else
             cattr_accessor :distance_column_name, :default_units, :default_formula, :lat_column_name, :lng_column_name, :qualified_lat_column_name, :qualified_lng_column_name
-        
+
             self.distance_column_name = options[:distance_column_name]  || 'distance'
             self.default_units = options[:default_units] || Geokit::default_units
             self.default_formula = options[:default_formula] || Geokit::default_formula
@@ -37,14 +37,14 @@ module Geokit
             self.lng_column_name = options[:lng_column_name] || 'lng'
             self.qualified_lat_column_name = "#{table_name}.#{lat_column_name}"
             self.qualified_lng_column_name = "#{table_name}.#{lng_column_name}"
-        
+
             if options.include?(:auto_geocode) && options[:auto_geocode]
               # if the form auto_geocode=>true is used, let the defaults take over by suppling an empty hash
-              options[:auto_geocode] = {} if options[:auto_geocode] == true 
+              options[:auto_geocode] = {} if options[:auto_geocode] == true
               cattr_accessor :auto_geocode_field, :auto_geocode_error_message
               self.auto_geocode_field = options[:auto_geocode][:field] || 'address'
               self.auto_geocode_error_message = options[:auto_geocode][:error_message] || 'could not locate address'
-        
+
               # set the actual callback here
               before_validation :auto_geocode_address, :on => :create
             end
@@ -52,16 +52,16 @@ module Geokit
         end
       end
     end # Glue
-    
+
     extend ActiveSupport::Concern
-    
+
     included do
       include Geokit::Mappable
     end
-    
+
     # Class methods included in models when +acts_as_mappable+ is called
     module ClassMethods
-      
+
       # A proxy to an instance of a finder adapter, inferred from the connection's adapter.
       def adapter
         @adapter ||= begin
@@ -74,23 +74,38 @@ module Geokit
         end
       end
       
+      def where(clause)
+        g self
+        pattern = Regexp.new("\\b#{distance_column_name}\\b")
+        value   = @distance_formula
+
+        g new_clause = if clause.is_a?(String)
+          clause.gsub!(pattern, value)
+        elsif clause.is_a?(Array)
+          clause.first.gsub!(pattern, value)
+        else
+          clause
+        end
+        super(new_clause)
+      end
+
       def within(distance, options = {})
         options[:within] = distance
         geo_scope(options)
       end
       alias inside within
-      
+
       def beyond(distance, options = {})
         options[:beyond] = distance
         geo_scope(options)
       end
       alias outside beyond
-      
+
       def in_range(range, options = {})
         options[:range] = range
         geo_scope(options)
       end
-      
+
       def in_bounds(bounds, options = {})
         options[:bounds] = bounds
         geo_scope(options)
@@ -107,30 +122,32 @@ module Geokit
 
       def geo_scope(options = {})
         arel = self.is_a?(ActiveRecord::Relation) ? self : self.scoped
-        
+
         origin  = extract_origin_from_options(options)
         units   = extract_units_from_options(options)
         formula = extract_formula_from_options(options)
         bounds  = extract_bounds_from_options(options)
-      
+
         if origin || bounds
           bounds = formulate_bounds_from_distance(options, origin, units) unless bounds
-        
+
           if origin
-            distance_formula = distance_sql(origin, units, formula)
+            @distance_formula = distance_sql(origin, units, formula)
             arel = arel.select('*') if arel.select_values.blank?
-            arel = arel.select("#{distance_formula} AS #{distance_column_name}")
+            arel = arel.select("#{@distance_formula} AS #{distance_column_name}")
           end
 
           if bounds
             bound_conditions = bound_conditions(bounds)
             arel = arel.where(bound_conditions) if bound_conditions
           end
-        
+
           distance_conditions = distance_conditions(options)
           arel = arel.where(distance_conditions) if distance_conditions
-          
-          arel = substitute_distance_in_where_values(arel, origin, units, formula)
+
+          if origin
+            arel = substitute_distance_in_where_values(arel, origin, units, formula)
+          end
         end
 
         arel
@@ -147,17 +164,17 @@ module Geokit
         end
         sql
       end
-      
+
       private
-      
+
       # If it's a :within query, add a bounding box to improve performance.
-      # This only gets called if a :bounds argument is not otherwise supplied. 
+      # This only gets called if a :bounds argument is not otherwise supplied.
       def formulate_bounds_from_distance(options, origin, units)
         distance = options[:within] if options.has_key?(:within)
         distance = options[:range].last-(options[:range].exclude_end?? 1 : 0) if options.has_key?(:range)
         if distance
           res=Geokit::Bounds.from_point_and_radius(origin,distance,:units=>units)
-        else 
+        else
           nil
         end
       end
@@ -177,47 +194,47 @@ module Geokit
         lng_sql = bounds.crosses_meridian? ? "(#{qualified_lng_column_name}<#{ne.lng} OR #{qualified_lng_column_name}>#{sw.lng})" : "#{qualified_lng_column_name}>#{sw.lng} AND #{qualified_lng_column_name}<#{ne.lng}"
         "#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
       end
-      
+
       # Extracts the origin instance out of the options if it exists and returns
-      # it.  If there is no origin, looks for latitude and longitude values to 
-      # create an origin.  The side-effect of the method is to remove these 
+      # it.  If there is no origin, looks for latitude and longitude values to
+      # create an origin.  The side-effect of the method is to remove these
       # option keys from the hash.
       def extract_origin_from_options(options)
         origin = options.delete(:origin)
         res = normalize_point_to_lat_lng(origin) if origin
         res
       end
-      
+
       # Extract the units out of the options if it exists and returns it.  If
-      # there is no :units key, it uses the default.  The side effect of the 
+      # there is no :units key, it uses the default.  The side effect of the
       # method is to remove the :units key from the options hash.
       def extract_units_from_options(options)
         units = options[:units] || default_units
         options.delete(:units)
         units
       end
-      
+
       # Extract the formula out of the options if it exists and returns it.  If
-      # there is no :formula key, it uses the default.  The side effect of the 
+      # there is no :formula key, it uses the default.  The side effect of the
       # method is to remove the :formula key from the options hash.
       def extract_formula_from_options(options)
         formula = options[:formula] || default_formula
         options.delete(:formula)
         formula
       end
-      
+
       def extract_bounds_from_options(options)
         bounds = options.delete(:bounds)
         bounds = Geokit::Bounds.normalize(bounds) if bounds
       end
-      
+
       # Geocode IP address.
       def geocode_ip_address(origin)
         geo_location = Geokit::Geocoders::MultiGeocoder.geocode(origin)
         return geo_location if geo_location.success
         raise Geokit::Geocoders::GeocodeError
       end
-      
+
       # Given a point in a variety of (an address to geocode,
       # an array of [lat,lng], or an object with appropriate lat/lng methods, an IP addres)
       # this method will normalize it into a Geokit::LatLng instance. The only thing this
@@ -227,8 +244,8 @@ module Geokit
         res = Geokit::LatLng.normalize(point) unless res
         res
       end
-      
-      # Looks for the distance column and replaces it with the distance sql. If an origin was not 
+
+      # Looks for the distance column and replaces it with the distance sql. If an origin was not
       # passed in and the distance column exists, we leave it to be flagged as bad SQL by the database.
       # Conditions are either a string or an array.  In the case of an array, the first entry contains
       # the condition.
@@ -244,43 +261,43 @@ module Geokit
         end
         arel
       end
-      
+
       # Returns the distance SQL using the spherical world formula (Haversine).  The SQL is tuned
       # to the database in use.
       def sphere_distance_sql(origin, units)
         lat = deg2rad(origin.lat)
         lng = deg2rad(origin.lng)
         multiplier = units_sphere_multiplier(units)
-      
+
         adapter.sphere_distance_sql(lat, lng, multiplier) if adapter
       end
-      
+
       # Returns the distance SQL using the flat-world formula (Phythagorean Theory).  The SQL is tuned
       # to the database in use.
       def flat_distance_sql(origin, units)
         lat_degree_units = units_per_latitude_degree(units)
         lng_degree_units = units_per_longitude_degree(origin.lat, units)
-        
+
         adapter.flat_distance_sql(origin, lat_degree_units, lng_degree_units)
       end
-      
+
     end # ClassMethods
 
     # this is the callback for auto_geocoding
     def auto_geocode_address
       address=self.send(auto_geocode_field).to_s
       geo=Geokit::Geocoders::MultiGeocoder.geocode(address)
-    
+
       if geo.success
         self.send("#{lat_column_name}=", geo.lat)
         self.send("#{lng_column_name}=", geo.lng)
       else
-        errors.add(auto_geocode_field, auto_geocode_error_message) 
+        errors.add(auto_geocode_field, auto_geocode_error_message)
       end
-    
+
       geo.success
     end
-    
+
     def self.end_of_reflection_chain(through, klass)
       while through
         reflection = nil
@@ -289,17 +306,17 @@ module Geokit
         else
           association, through = through, nil
         end
-    
+
         if reflection = klass.reflect_on_association(association)
           klass = reflection.klass
         else
           raise ArgumentError, "You gave #{association} in :through, but I could not find it on #{klass}."
         end
       end
-    
+
       reflection
     end
-    
+
   end # ActsAsMappable
 end # Geokit
 

data/lib/geokit-rails3/railtie.rb

@@ -3,7 +3,7 @@ require 'rails'
 
 module Geokit
 
-  class Railtie < Rails::Railtie
+  class Railtie < ::Rails::Railtie
 
     config.geokit = ActiveSupport::OrderedOptions.new
     config.geokit.geocoders = ActiveSupport::OrderedOptions.new

data/lib/geokit-rails3/version.rb

@@ -1,3 +1,3 @@
 module GeokitRails3
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/test/acts_as_mappable_test.rb

@@ -3,9 +3,9 @@ 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
@@ -14,439 +14,494 @@ 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_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.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
+    locations = Location.geo_scope(:origin => @loc_a).where("distance < 3.97")
+    assert_equal 5, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :conditions => "distance < 3.97")
+    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.find(:all, :origin => @loc_a, :order => "distance ASC")
+    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.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
+    locations = Location.geo_scope(:origin => @loc_a, :within => 3.97)
+    assert_equal 5, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :conditions => "distance < 3.97")
+    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.find(:all, :origin => @loc_a, :units => :kms, :conditions => "distance < 6.387")
+    locations = Location.geo_scope(:origin => @loc_a, :units => :kms, :within => 6.387)
+    assert_equal 5, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :units => :kms, :conditions => "distance < 6.387")
+    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.find(:all, :origin => @loc_a, :formula => :flat, :conditions => "distance < 6.387")
+    locations = Location.geo_scope(:origin => @loc_a, :formula => :flat, :within => 6.387)
+    assert_equal 6, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :formula => :flat, :conditions => "distance < 6.387")
+    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
+    # locations = Location.count_within(3.97, :origin => @loc_a)
+    assert_equal 5, locations.count
+  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
+
   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
+    # locations = Location.count_within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
+    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.find(:all, :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
+    locations = Location.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
+    assert_equal 2, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
+    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.find(:all, :origin => @loc_a, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
+    locations = Location.geo_scope(:origin => @loc_a).where(["distance < ? and city = ?", 5, 'Coppell'])
+    assert_equal 2, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
+    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.find_beyond(3.95, :origin => @loc_a)
+    locations = Location.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    # locations = Location.count_beyond(3.95, :origin => @loc_a)
+    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
+    # locations = Location.count(:beyond => 3.95, :origin => @loc_a)
+    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.find_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    locations = Location.beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal 1, locations.all.size
+    # locations = Location.count_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    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.find(:all, :range => 0..10, :origin => @loc_a)
+    locations = Location.geo_scope(:range => 0..10, :origin => @loc_a)
+    assert_equal 6, locations.all.size
+    # locations = Location.count(:range => 0..10, :origin => @loc_a)
+    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.find(:all, :origin => @loc_a, :range => 0..10, :conditions => ["city = ?", 'Coppell'])
+    locations = Location.geo_scope(:origin => @loc_a, :range => 0..10).where(["city = ?", 'Coppell'])
+    assert_equal 2, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :range => 0..10, :conditions => ["city = ?", 'Coppell'])
+    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.find(:all, :origin => @loc_a, :range => 0..10, :conditions => {:city => 'Coppell'})
+    locations = Location.geo_scope(:origin => @loc_a, :range => 0..10).where(:city => 'Coppell')
+    assert_equal 2, locations.all.size
+    # locations = Location.count(:origin => @loc_a, :range => 0..10, :conditions => {:city => 'Coppell'})
+    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.find(:all, :range => 0...10, :origin => @loc_a)
+    locations = Location.geo_scope(:range => 0...10, :origin => @loc_a)
+    assert_equal 6, locations.all.size
+    # locations = Location.count(:range => 0...10, :origin => @loc_a)
+    assert_equal 6, locations.count
   end
-  
+
   def test_find_nearest
-    assert_equal @loc_a, Location.find_nearest(:origin => @loc_a)
-  end
-  
-  def test_find_nearest_through_find
-     assert_equal @loc_a, Location.find(:nearest, :origin => @loc_a)
+    # 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.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)
+    # 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_through_find
-    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)
+  # 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.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.find(:all, :origin => @loc_a, :order => "distance ASC")
+    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.find(:all, :origin => @loc_a, :conditions => "distance < 3.97")
+    locations = @starbucks.locations.geo_scope(:origin => @loc_a).where("distance < 3.97")
+    assert_equal 4, locations.all.size
+    # locations = @starbucks.locations.count(:origin => @loc_a, :conditions => "distance < 3.97")
+    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.find_within(3.97, :origin => @loc_a)
+    locations = @starbucks.locations.within(3.97, :origin => @loc_a)
+    assert_equal 4, locations.all.size
+    # locations = @starbucks.locations.count_within(3.97, :origin => @loc_a)
+    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.find(:all, :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
+    locations = @starbucks.locations.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
+    assert_equal 2, locations.all.size
+    # locations = @starbucks.locations.count( :origin => @loc_a, :conditions => "distance < 5 and city = 'Coppell'")
+    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.find_beyond(3.95, :origin => @loc_a)
+    locations = @starbucks.locations.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    # locations = @starbucks.locations.count_beyond(3.95, :origin => @loc_a)
+    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.find_nearest(:origin => @loc_a).first
+    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.find_farthest(:origin => @loc_a).first
+    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.find(:all, :origin => LOCATION_A_IP, :order => "distance ASC")
+    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.find(:all, :origin => LOCATION_A_IP, :conditions => "distance < 3.97")
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).where2("distance < 3.97")
+    assert_equal 5, locations.all.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.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.find_within(3.97, :origin => LOCATION_A_IP)
+    locations = Location.within(3.97, :origin => LOCATION_A_IP)
+    assert_equal 5, locations.all.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.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.find(:all, :origin => LOCATION_A_IP, :conditions => "distance < 5 and city = 'Coppell'")
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).where("distance < 5 and city = 'Coppell'")
+    assert_equal 2, locations.all.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.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.find(:all, :origin => LOCATION_A_IP, :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
+    locations = Location.geo_scope(:origin => LOCATION_A_IP).where(["distance < ? and city = ?", 5, 'Coppell'])
+    assert_equal 2, locations.all.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.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.find_beyond(3.95, :origin => LOCATION_A_IP)
+    locations = Location.beyond(3.95, :origin => LOCATION_A_IP)
+    assert_equal 1, locations.all.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.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.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.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.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.find(:all, :origin => 'Irving, TX', :conditions => ["distance < ? and city = ?", 5, 'Coppell'])
+    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.find(:all, :origin => @loc_a, :conditions => "dist < 3.97")
+    locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 3.97")
+    assert_equal 5, locations.all.size
+    # locations = CustomLocation.count(:origin => @loc_a, :conditions => "dist < 3.97")
+    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.find(:all, :origin => @custom_loc_a, :conditions => "dist < 3.97")
+    locations = CustomLocation.geo_scope(:origin => @custom_loc_a).where("dist < 3.97")
+    assert_equal 5, locations.all.size
+    locations = CustomLocation.count(:origin => @custom_loc_a).where("dist < 3.97")
+    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.find_within(3.97, :origin => @loc_a)
+    locations = CustomLocation.within(3.97, :origin => @loc_a)
+    assert_equal 5, locations.all.size
+    # locations = CustomLocation.count_within(3.97, :origin => @loc_a)
+    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.find_within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
+    locations = CustomLocation.within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal 5, locations.all.size
+    # locations = CustomLocation.count_within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
+    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.find(:all, :origin => @loc_a, :conditions => "dist < 5 and city = 'Coppell'")
+    locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 5 and city = 'Coppell'")
+    assert_equal 1, locations.all.size
+    # locations = CustomLocation.count(:origin => @loc_a, :conditions => "dist < 5 and city = 'Coppell'")
+    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.find(:all, :origin => @loc_a, :conditions => ["dist < ? and city = ?", 5, 'Coppell'])
+    locations = CustomLocation.geo_scope(:origin => @loc_a).where(["dist < ? and city = ?", 5, 'Coppell'])
+    assert_equal 1, locations.all.size
+    # locations = CustomLocation.count(:origin => @loc_a, :conditions => ["dist < ? and city = ?", 5, 'Coppell'])
+    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.find_beyond(3.95, :origin => @loc_a)
+    locations = CustomLocation.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.all.size
+    # locations = CustomLocation.count_beyond(3.95, :origin => @loc_a)
+    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.find_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    locations = CustomLocation.beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    assert_equal 1, locations.all.size
+    # locations = CustomLocation.count_beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
+    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.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.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.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.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.find(:all, :origin =>[@loc_a.lat,@loc_a.lng], :conditions => "distance < 3.97")
+    locations = Location.geo_scope(:origin =>[@loc_a.lat,@loc_a.lng]).where("distance < 3.97")
+    assert_equal 5, locations.all.size
+    # locations = Location.count(:origin =>[@loc_a.lat,@loc_a.lng], :conditions => "distance < 3.97")
+    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.find_within_bounds([@sw,@ne])
+    locations = Location.in_bounds([@sw,@ne])
+    assert_equal 2, locations.all.size
+    # locations = Location.count_within_bounds([@sw,@ne])
+    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.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.find(:all, :bounds=>[@sw,@ne])
+    locations = Location.geo_scope(:bounds=>[@sw,@ne])
+    assert_equal 2, locations.all.size
+    # locations = Location.count(:bounds=>[@sw,@ne])
+    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.find(:all, :bounds=>[@sw,@ne], :conditions=>"id !=#{locations(:a).id}")
+    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.find(:all, :bounds=>[@sw,@ne], :conditions=>["id != ?", locations(:a).id])
+    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.find(:all, :bounds=>[@sw,@ne], :conditions=>{:id => locations(:a).id})
+    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')
@@ -454,20 +509,23 @@ 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.find(:all, :origin => @location_a, :order => 'distance ASC')
+    organizations = MockOrganization.geo_scope(:origin => @location_a).order('distance ASC')
+    assert_equal 2, organizations.all.size
+    # organizations = MockOrganization.count(:origin => @location_a, :conditions => "distance < 3.97")
+    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.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")
+    # people = MockPerson.count(:origin => @location_a, :conditions => "distance < 3.97")
     assert_equal 2, people
-  end 
+  end
 end