geokit-rails 2.0.0.rc1 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjMwNjUzNmI4NzQ5M2Q2NTZiZGEwZTFkZDFlNjQ0MWE5Mzk1OGJkMQ==
+    NDM3YThmODQ4MTE4ZDFlNWJjN2UxNmY2N2Q1NzcxODYxM2E0OTA2Mg==
   data.tar.gz: !binary |-
-    N2E4MTgzZDk4YmVkNzIyMDg0N2RiOTMyMzdhYzgxNGVkMDZmZDgyOQ==
+    ZDUxYzUyMWExNzNiMDBkZWJjMTRkOWI1NzExNTY3NTM3Zjk2NDRjZg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NjE3ZWE2ZGY4MzkxOWFmOTc3N2RiM2U3ZTVmODdjOTQwNDgyYTQ4YjRkM2Y4
-    NmJkOWViMjUyN2I2NDcwMzBmOWUwYWE4ZmIzMGVhMGViNDFkMTRkZWI5YjNh
-    YTI4NjAyYzc4MGEwOGY2NWI1MjJhMDBkOTZiMjJkOWE4NWYxZDg=
+    ZGYwMTc5MWZjYTk0YmFjNTJhZGYyNTE0MjAyZmM1ZjhlYjViNTEzMWIzNmVk
+    NGVkMmFjMjQ0NjA3NjJhYWIzMzQyYTI3OTBmZjFkYWQxOGE3ODg0NzI2OTc1
+    MjliZmFkYTk0YjM4MTFkZDFmZDBhNWU2YjAzNjg3MDdiNWE1OTk=
   data.tar.gz: !binary |-
-    MDQ1MDY2N2JjNjhkMzRiZjdhMDljMzUyNGI4NDU5YzNjMDdkNjcyNzcyN2Q2
-    YTBmODg3NWU3YzhiNWFkMjA1YzU3N2VmOTQ1MzdmNTE4M2RjZjljY2MwOTMz
-    YTQzOWY0ZGUwNDI5NWVmMjBjNjJiZmIwNjQ2MzZjNzk5NmM5NmY=
+    OTFiYTJiZmRhZTRiMTA1NjEyNDYyODU2ZWQwZDlhY2FkODQ4YzNlYTdkN2Y2
+    YWQ0NjkyYjg4ZjgwODdjMjMxNzM4ODk3NzQyODk3MjA0MzJlODYwNDk4YjFm
+    OTU3YWZlM2JmOGU1ODE1YzIyNjcyNTg0MmZjZjU2MGE3OGQwNjc=

data/lib/geokit-rails/acts_as_mappable.rb

@@ -53,33 +53,33 @@ module Geokit
       end
     end # Glue
 
-    class Relation < ActiveRecord::Relation
-      attr_accessor :distance_formula
-
-      def where(opts, *rest)
-        return self if opts.blank?
-        relation = clone
-        where_values = build_where(opts, rest)
-        relation.where_values += substitute_distance_in_values(where_values)
-        relation
-      end
-
-      def order(*args)
-        return self if args.blank?
-        relation = clone
-        order_values = args.flatten
-        relation.order_values += substitute_distance_in_values(order_values)
-        relation
-      end
-
-    private
-      def substitute_distance_in_values(values)
-        return values unless @distance_formula
-        # substitute distance with the actual distance equation
-        pattern = Regexp.new("\\b#{@klass.distance_column_name}\\b")
-        values.map {|value| value.is_a?(String) ? value.gsub(pattern, @distance_formula) : value }
-      end
-    end
+    #class Relation < ActiveRecord::Relation
+    #  attr_accessor :distance_formula
+
+    #  def where(opts, *rest)
+    #    return self if opts.blank?
+    #    relation = clone
+    #    where_values = build_where(opts, rest)
+    #    relation.where_values += substitute_distance_in_values(where_values)
+    #    relation
+    #  end
+
+    #  def order(*args)
+    #    return self if args.blank?
+    #    relation = clone
+    #    order_values = args.flatten
+    #    relation.order_values += substitute_distance_in_values(order_values)
+    #    relation
+    #  end
+
+    #private
+    #  def substitute_distance_in_values(values)
+    #    return values unless @distance_formula
+    #    # substitute distance with the actual distance equation
+    #    pattern = Regexp.new("\\b#{@klass.distance_column_name}\\b")
+    #    values.map {|value| value.is_a?(String) ? value.gsub(pattern, @distance_formula) : value }
+    #  end
+    #end
 
     extend ActiveSupport::Concern
 
@@ -104,28 +104,40 @@ module Geokit
 
       def within(distance, options = {})
         options[:within] = distance
-        geo_scope(options)
+        #geo_scope(options)
+        where(distance_conditions(options))
       end
       alias inside within
 
       def beyond(distance, options = {})
         options[:beyond] = distance
-        geo_scope(options)
+        #geo_scope(options)
+        where(distance_conditions(options))
       end
       alias outside beyond
 
       def in_range(range, options = {})
         options[:range] = range
-        geo_scope(options)
+        #geo_scope(options)
+        where(distance_conditions(options))
       end
 
       def in_bounds(bounds, options = {})
         options[:bounds] = bounds
-        geo_scope(options)
+        #geo_scope(options)
+        #where(distance_conditions(options))
+        bounds  = extract_bounds_from_options(options)
+        where(bound_conditions(bounds))
       end
 
       def by_distance(options = {})
-        geo_scope(options).order("#{distance_column_name} asc")
+        origin  = extract_origin_from_options(options)
+        units   = extract_units_from_options(options)
+        formula = extract_formula_from_options(options)
+        bounds  = extract_bounds_from_options(options)
+        distance_column_name = distance_sql(origin, units, formula)
+        #geo_scope(options).order("#{distance_column_name} asc")
+        order("#{distance_column_name} asc")
       end
 
       def closest(options = {})
@@ -137,41 +149,41 @@ module Geokit
         by_distance(options).last(1)
       end
 
-      def geo_scope(options = {})
-        arel = self.is_a?(ActiveRecord::Relation) ? self : self.scoped
+      #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)
+      #  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 || bounds
+      #    bounds = formulate_bounds_from_distance(options, origin, units) unless bounds
 
-          if origin
-            arel.distance_formula = distance_sql(origin, units, formula)
-            
-            if arel.select_values.blank?
-              star_select = Arel::SqlLiteral.new(arel.quoted_table_name + '.*')
-              arel = arel.select(star_select)
-            end
-          end
+      #    if origin
+      #      arel.distance_formula = distance_sql(origin, units, formula)
+      #      
+      #      if arel.select_values.blank?
+      #        star_select = Arel::SqlLiteral.new(arel.quoted_table_name + '.*')
+      #        arel = arel.select(star_select)
+      #      end
+      #    end
 
-          if bounds
-            bound_conditions = bound_conditions(bounds)
-            arel = arel.where(bound_conditions) if bound_conditions
-          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
+      #    distance_conditions = distance_conditions(options)
+      #    arel = arel.where(distance_conditions) if distance_conditions
 
-          if self.through
-            arel = arel.includes(self.through)
-          end
-        end
+      #    if self.through
+      #      arel = arel.includes(self.through)
+      #    end
+      #  end
 
-        arel
-      end
+      #  arel
+      #end
 
       # Returns the distance calculation to be used as a display column or a condition.  This
       # is provide for anyone wanting access to the raw SQL.
@@ -189,12 +201,12 @@ module Geokit
 
       # Override ActiveRecord::Base.relation to return an instance of Geokit::ActsAsMappable::Relation.
       # TODO: Do we need to override JoinDependency#relation too?
-      def relation
-        # NOTE: This cannot be @relation as ActiveRecord already uses this to
-        # cache *its* Relation object
-        @_geokit_relation ||= Relation.new(self, arel_table)
-        finder_needs_type_condition? ? @_geokit_relation.where(type_condition) : @_geokit_relation
-      end
+      #def relation
+      #  # NOTE: This cannot be @relation as ActiveRecord already uses this to
+      #  # cache *its* Relation object
+      #  @_geokit_relation ||= Relation.new(self, arel_table)
+      #  finder_needs_type_condition? ? @_geokit_relation.where(type_condition) : @_geokit_relation
+      #end
 
       # 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.
@@ -209,6 +221,12 @@ module Geokit
       end
 
       def distance_conditions(options)
+        origin  = extract_origin_from_options(options)
+        units   = extract_units_from_options(options)
+        formula = extract_formula_from_options(options)
+        bounds  = extract_bounds_from_options(options)
+        distance_column_name = distance_sql(origin, units, formula)
+
         res = if options.has_key?(:within)
           "#{distance_column_name} <= #{options[:within]}"
         elsif options.has_key?(:beyond)
@@ -223,7 +241,8 @@ module Geokit
         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}"
         res = "#{qualified_lat_column_name}>#{sw.lat} AND #{qualified_lat_column_name}<#{ne.lat} AND #{lng_sql}"
-        Arel::SqlLiteral.new("(#{res})") if res.present?
+        #Arel::SqlLiteral.new("(#{res})") if res.present?
+        res if res.present?
       end
 
       # Extracts the origin instance out of the options if it exists and returns
@@ -353,4 +372,4 @@ end # Geokit
 
 
 
-# ActiveRecord::Base.extend Geokit::ActsAsMappable
+# ActiveRecord::Base.extend Geokit::ActsAsMappable

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

@@ -1,22 +1,8 @@
+require 'geokit-rails/adapters/mysql'
+
 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
-      
+    class Mysql2 < MySQL
     end
   end
-end
+end

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

@@ -0,0 +1,8 @@
+require 'geokit-rails/adapters/mysql'
+
+module Geokit
+  module Adapters
+    class Mysql2Spatial < MySQL
+    end
+  end
+end

data/lib/geokit-rails/version.rb

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

data/test/acts_as_mappable_test.rb

@@ -29,26 +29,18 @@ class ActsAsMappableTest < GeokitTestCase
     @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.geo_scope(:origin => @loc_a).where("distance < 3.97")
-    assert_equal 5, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a).where("distance < 3.97")
+    locations = Location.within(3.9, :origin => @loc_a)
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
     Location.default_units = :miles
   end
 
   def test_include
-    locations = Location.geo_scope(:origin => @loc_a).includes(:company).where("company_id = 1").all
+    #locations = Location.geo_scope(:origin => @loc_a).includes(:company).where("company_id = 1").all
+    locations = Location.includes(:company).where("company_id = 1").to_a
     assert !locations.empty?
     assert_equal 1, locations[0].company.id
     assert_equal 'Starbucks', locations[0].company.name
@@ -76,94 +68,102 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_distance_column_in_select
-    locations = Location.geo_scope(:origin => @loc_a).order("distance ASC")
-    assert_equal 6, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a).order("distance ASC")
+    locations = Location.by_distance(:origin => @loc_a)
+    assert_equal 6, locations.to_a.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.geo_scope(:origin => @loc_a, :within => 3.97)
-    assert_equal 5, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a, :within => 3.97)
+    locations = Location.within(3.97, :origin => @loc_a)
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_with_distance_condition_with_units_override
-    locations = Location.geo_scope(:origin => @loc_a, :units => :kms, :within => 6.387)
-    assert_equal 5, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a, :units => :kms, :within => 6.387)
+    locations = Location.within(6.387, :origin => @loc_a, :units => :kms)
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_with_distance_condition_with_formula_override
-    locations = Location.geo_scope(:origin => @loc_a, :formula => :flat, :within => 6.387)
-    assert_equal 6, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a, :formula => :flat, :within => 6.387)
+    locations = Location.within(6.387, :origin => @loc_a, :formula => :flat)
+    assert_equal 6, locations.to_a.size
     assert_equal 6, locations.count
   end
 
   def test_find_within
     locations = Location.within(3.97, :origin => @loc_a)
-    assert_equal 5, locations.all.size
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   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
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_with_compound_condition
-    locations = Location.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
+    locations = Location.within(5, :origin => @loc_a).where("city = 'Coppell'")
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_with_secure_compound_condition
-    locations = Location.geo_scope(:origin => @loc_a).where(["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.all.size
+    #locations = Location.geo_scope(:origin => @loc_a).where(["distance < ? and city = ?", 5, 'Coppell'])
+    locations = Location.within(5, :origin => @loc_a).where(["city = ?", 'Coppell'])
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_beyond
     locations = Location.beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.all.size
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
   def test_find_beyond_with_token
     # 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.geo_scope(:beyond => 3.95, :origin => @loc_a)
+    locations = Location.beyond(3.95, :origin => @loc_a)
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
   def test_find_beyond_with_coordinates
     locations = Location.beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations.all.size
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
   def test_find_range_with_token
-    locations = Location.geo_scope(:range => 0..10, :origin => @loc_a)
-    assert_equal 6, locations.all.size
+    locations = Location.in_range(0..10, :origin => @loc_a)
+    assert_equal 6, locations.to_a.size
     assert_equal 6, locations.count
   end
 
   def test_find_range_with_token_with_conditions
-    locations = Location.geo_scope(:origin => @loc_a, :range => 0..10).where(["city = ?", 'Coppell'])
-    assert_equal 2, locations.all.size
+    locations = Location.in_range(0..10, :origin => @loc_a).where(["city = ?", 'Coppell'])
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_range_with_token_with_hash_conditions
-    locations = Location.geo_scope(:origin => @loc_a, :range => 0..10).where(:city => 'Coppell')
-    assert_equal 2, locations.all.size
+    locations = Location.in_range(0..10, :origin => @loc_a).where(:city => 'Coppell')
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_range_with_token_excluding_end
-    locations = Location.geo_scope(:range => 0...10, :origin => @loc_a)
-    assert_equal 6, locations.all.size
+    #locations = Location.geo_scope(:range => 0...10, :origin => @loc_a)
+    locations = Location.in_range(0...10, :origin => @loc_a)
+    assert_equal 6, locations.to_a.size
     assert_equal 6, locations.count
   end
 
@@ -184,33 +184,35 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_scoped_distance_column_in_select
-    locations = @starbucks.locations.geo_scope(:origin => @loc_a).order("distance ASC")
-    assert_equal 5, locations.all.size
+    #locations = @starbucks.locations.geo_scope(:origin => @loc_a).order("distance ASC")
+    locations = @starbucks.locations.by_distance(:origin => @loc_a)
+    assert_equal 5, locations.to_a.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.geo_scope(:origin => @loc_a).where("distance < 3.97")
-    assert_equal 4, locations.all.size
+    #locations = @starbucks.locations.geo_scope(:origin => @loc_a).where("distance < 3.97")
+    locations = @starbucks.locations.within(3.97, :origin => @loc_a)
+    assert_equal 4, locations.to_a.size
     assert_equal 4, locations.count
   end
 
   def test_scoped_find_within
     locations = @starbucks.locations.within(3.97, :origin => @loc_a)
-    assert_equal 4, locations.all.size
+    assert_equal 4, locations.to_a.size
     assert_equal 4, locations.count
   end
 
   def test_scoped_find_with_compound_condition
-    locations = @starbucks.locations.geo_scope(:origin => @loc_a).where("distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.all.size
+    locations = @starbucks.locations.within(5, :origin => @loc_a).where("city = 'Coppell'")
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_scoped_find_beyond
     locations = @starbucks.locations.beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.all.size
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
@@ -224,44 +226,44 @@ class ActsAsMappableTest < GeokitTestCase
 
   def test_ip_geocoded_distance_column_in_select
     GeoKit::Geocoders::MultiGeocoder.expects(:geocode).with(LOCATION_A_IP).returns(@location_a)
-    locations = Location.geo_scope(:origin => LOCATION_A_IP).order("distance ASC")
-    assert_equal 6, locations.all.size
+    locations = Location.by_distance(:origin => LOCATION_A_IP)
+    assert_equal 6, locations.to_a.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.geo_scope(:origin => LOCATION_A_IP).where("distance < 3.97")
-    assert_equal 5, locations.all.size
+    locations = Location.within(3.97, :origin => LOCATION_A_IP)
+    assert_equal 5, locations.to_a.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.within(3.97, :origin => LOCATION_A_IP)
-    assert_equal 5, locations.all.size
+    assert_equal 5, locations.to_a.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.geo_scope(:origin => LOCATION_A_IP).where("distance < 5 and city = 'Coppell'")
-    assert_equal 2, locations.all.size
+    locations = Location.within(5, :origin => LOCATION_A_IP).where("city = 'Coppell'")
+    assert_equal 2, locations.to_a.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.geo_scope(:origin => LOCATION_A_IP).where(["distance < ? and city = ?", 5, 'Coppell'])
-    assert_equal 2, locations.all.size
+    locations = Location.within(5, :origin => LOCATION_A_IP).where(["city = ?", 'Coppell'])
+    assert_equal 2, locations.to_a.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.beyond(3.95, :origin => LOCATION_A_IP)
-    assert_equal 1, locations.all.size
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
@@ -284,56 +286,60 @@ class ActsAsMappableTest < GeokitTestCase
 
   def test_address_geocode
     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
+    #locations = Location.geo_scope(:origin => 'Irving, TX').where(["distance < ? and city = ?", 5, 'Coppell'])
+    locations = Location.within(5, :origin => 'Irving, TX').where(["city = ?", 'Coppell'])
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_with_custom_distance_condition
-    locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 3.97")
-    assert_equal 5, locations.all.size
+    locations = CustomLocation.within(3.97, :origin => @loc_a)
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_with_custom_distance_condition_using_custom_origin
-    locations = CustomLocation.geo_scope(:origin => @custom_loc_a).where("dist < 3.97")
-    assert_equal 5, locations.all.size
+    #locations = CustomLocation.geo_scope(:origin => @custom_loc_a).where("dist < 3.97")
+    locations = CustomLocation.within(3.97, :origin => @custom_loc_a)
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_within_with_custom
     locations = CustomLocation.within(3.97, :origin => @loc_a)
-    assert_equal 5, locations.all.size
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_within_with_coordinates_with_custom
     locations = CustomLocation.within(3.97, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 5, locations.all.size
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
   def test_find_with_compound_condition_with_custom
-    locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 5 and city = 'Coppell'")
-    assert_equal 1, locations.all.size
+    #locations = CustomLocation.geo_scope(:origin => @loc_a).where("dist < 5 and city = 'Coppell'")
+    locations = CustomLocation.within(5, :origin => @loc_a).where("city = 'Coppell'")
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
-  def test_find_with_secure_compound_condition_with_custom
-    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
+  # REMOVED AS SAME AS BELOW
+  #def test_find_with_secure_compound_condition_with_custom
+  #  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.beyond(3.95, :origin => @loc_a)
-    assert_equal 1, locations.all.size
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
   def test_find_beyond_with_coordinates_with_custom
     locations = CustomLocation.beyond(3.95, :origin =>[@loc_a.lat, @loc_a.lng])
-    assert_equal 1, locations.all.size
+    assert_equal 1, locations.to_a.size
     assert_equal 1, locations.count
   end
 
@@ -354,8 +360,9 @@ class ActsAsMappableTest < GeokitTestCase
   end
 
   def test_find_with_array_origin
-    locations = Location.geo_scope(:origin =>[@loc_a.lat,@loc_a.lng]).where("distance < 3.97")
-    assert_equal 5, locations.all.size
+    #locations = Location.geo_scope(:origin =>[@loc_a.lat,@loc_a.lng]).where("distance < 3.97")
+    locations = Location.within(3.97, :origin =>[@loc_a.lat,@loc_a.lng])
+    assert_equal 5, locations.to_a.size
     assert_equal 5, locations.count
   end
 
@@ -364,35 +371,40 @@ class ActsAsMappableTest < GeokitTestCase
 
   def test_find_within_bounds
     locations = Location.in_bounds([@sw,@ne])
-    assert_equal 2, locations.all.size
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_within_bounds_ordered_by_distance
-    locations = Location.in_bounds([@sw,@ne], :origin=>@bounds_center).order('distance asc')
+    #locations = Location.in_bounds([@sw,@ne], :origin=>@bounds_center).order('distance asc')
+    locations = Location.in_bounds([@sw,@ne]).by_distance(:origin => @bounds_center)
     assert_equal locations[0], locations(:d)
     assert_equal locations[1], locations(:a)
   end
 
   def test_find_within_bounds_with_token
-    locations = Location.geo_scope(:bounds=>[@sw,@ne])
-    assert_equal 2, locations.all.size
+    #locations = Location.geo_scope(:bounds=>[@sw,@ne])
+    locations = Location.in_bounds([@sw,@ne])
+    assert_equal 2, locations.to_a.size
     assert_equal 2, locations.count
   end
 
   def test_find_within_bounds_with_string_conditions
-    locations = Location.geo_scope(:bounds=>[@sw,@ne]).where("id !=#{locations(:a).id}")
-    assert_equal 1, locations.all.size
+    #locations = Location.geo_scope(:bounds=>[@sw,@ne]).where("id !=#{locations(:a).id}")
+    locations = Location.in_bounds([@sw,@ne]).where("id !=#{locations(:a).id}")
+    assert_equal 1, locations.to_a.size
   end
 
   def test_find_within_bounds_with_array_conditions
-    locations = Location.geo_scope(:bounds=>[@sw,@ne]).where(["id != ?", locations(:a).id])
-    assert_equal 1, locations.all.size
+    #locations = Location.geo_scope(:bounds=>[@sw,@ne]).where(["id != ?", locations(:a).id])
+    locations = Location.in_bounds([@sw,@ne]).where(["id != ?", locations(:a).id])
+    assert_equal 1, locations.to_a.size
   end
 
   def test_find_within_bounds_with_hash_conditions
-    locations = Location.geo_scope(:bounds=>[@sw,@ne]).where({:id => locations(:a).id})
-    assert_equal 1, locations.all.size
+    #locations = Location.geo_scope(:bounds=>[@sw,@ne]).where({:id => locations(:a).id})
+    locations = Location.in_bounds([@sw,@ne]).where({:id => locations(:a).id})
+    assert_equal 1, locations.to_a.size
   end
 
   def test_auto_geocode
@@ -414,15 +426,16 @@ class ActsAsMappableTest < GeokitTestCase
 
   # Test :through
 
-  def test_find_with_through
-    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
+  #  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.geo_scope(:origin => @location_a).order('distance ASC')
+    #people = MockPerson.geo_scope(:origin => @location_a).order('distance ASC')
+    people = MockPerson.order('distance ASC')
     assert_equal 2, people.size
     assert_equal 2, people.count
   end