geokit-rails3 0.1.2 → 0.1.3

data/lib/geokit-rails3/acts_as_mappable.rb

@@ -14,7 +14,7 @@ module Geokit
         def acts_as_mappable(options = {})
           metaclass = (class << self; self; end)
 
-          self.send :include, Geokit::ActsAsMappable
+          include Geokit::ActsAsMappable
 
           cattr_accessor :through
           self.through = options[:through]
@@ -118,8 +118,14 @@ module Geokit
 
           if origin
             @distance_formula = distance_sql(origin, units, formula)
-            arel = arel.select('*') if arel.select_values.blank?
-            arel = arel.select("#{@distance_formula} AS #{distance_column_name}")
+            
+            if arel.select_values.blank?
+              star_select = Arel::SqlLiteral.new(arel.quoted_table_name + '.*')
+              arel = arel.select(star_select)
+            end
+            
+            distance_select = Arel::SqlLiteral.new("#{@distance_formula} AS #{distance_column_name}")
+            arel = arel.select(distance_select)
           end
 
           if bounds
@@ -165,19 +171,21 @@ module Geokit
       end
 
       def distance_conditions(options)
-        if options.has_key?(:within)
+        res = if options.has_key?(:within)
           "#{distance_column_name} <= #{options[:within]}"
         elsif options.has_key?(:beyond)
           "#{distance_column_name} > #{options[:beyond]}"
         elsif options.has_key?(:range)
           "#{distance_column_name} >= #{options[:range].first} AND #{distance_column_name} <#{'=' unless options[:range].exclude_end?} #{options[:range].last}"
         end
+        Arel::SqlLiteral.new("(#{res})") if res.present?
       end
 
       def bound_conditions(bounds)
         sw,ne = bounds.sw, bounds.ne
         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}"
+        res = "#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
+        Arel::SqlLiteral.new("(#{res})") if res.present?
       end
 
       # Extracts the origin instance out of the options if it exists and returns

data/lib/geokit-rails3/version.rb

@@ -1,3 +1,3 @@
 module GeokitRails3
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/test/acts_as_mappable_test.rb

@@ -31,10 +31,8 @@ class ActsAsMappableTest < GeokitTestCase
 
   def test_override_default_units_the_hard_way
     Location.default_units = :kms
-    # 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
@@ -68,7 +66,6 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_distance_column_in_select
-    # 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)
@@ -76,71 +73,50 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_find_with_distance_condition
-    # 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")
     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")
     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.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.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'")
     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'])
     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)
     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
 
@@ -148,80 +124,56 @@ class ActsAsMappableTest < GeokitTestCase
     # 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])
     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)
     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'])
     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'})
     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)
     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)
     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)
     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_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")
     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)
@@ -229,50 +181,39 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_scoped_find_with_distance_condition
-    # 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)
     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'")
     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)
     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).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).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")
     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)
@@ -281,92 +222,70 @@ class ActsAsMappableTest < GeokitTestCase
 
   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")
     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)
     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'")
     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'])
     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)
     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.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'])
     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")
     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")
     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")
@@ -374,78 +293,60 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_find_within_with_custom
-    # 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])
     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'")
     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'])
     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)
     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])
     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.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")
     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
 
@@ -453,42 +354,34 @@ class ActsAsMappableTest < GeokitTestCase
   # Bounding box tests
 
   def test_find_within_bounds
-    # 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.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])
     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}")
     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])
     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})
     locations = Location.geo_scope(:bounds=>[@sw,@ne]).where({:id => locations(:a).id})
     assert_equal 1, locations.all.size
   end
@@ -513,19 +406,15 @@ class ActsAsMappableTest < GeokitTestCase
   # Test :through
 
   def test_find_with_through
-    # 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.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
 end