activerecord-spatial 1.0.0 → 2.0.0

data/test/associations_tests.rb

@@ -1,5 +1,5 @@
 
-$: << File.dirname(__FILE__)
+$LOAD_PATH << File.dirname(__FILE__)
 require 'test_helper'
 
 class DefaultIntersectsRelationshipTest < ActiveRecordSpatialTestCase
@@ -12,12 +12,18 @@ class DefaultIntersectsRelationshipTest < ActiveRecordSpatialTestCase
   end
 
   def test_reflection
-    assert_equal(:has_many, Foo.reflections[:bars].macro)
-    assert_equal(:intersects, Foo.reflections[:bars].options[:relationship])
+    assert_equal(:has_many, Foo.reflections[reflection_key(:bars)].macro)
+    assert_equal(:intersects, Foo.reflections[reflection_key(:bars)].options[:relationship])
   end
 
   def test_association
-    assert_equal([ 3 ], Foo.first.bars.collect(&:id).sort)
+    values = nil
+
+    assert_sql(/ST_intersects\('#{REGEXP_WKB_HEX}'::geometry, "bars"\."the_geom"/) do
+      values = Foo.first.bars.collect(&:id).sort
+    end
+
+    assert_equal([3], values)
   end
 end
 
@@ -27,19 +33,19 @@ class RelationshipsTest < ActiveRecordSpatialTestCase
   end
 
   {
-    :contains => [],
-    :containsproperly => [],
-    :covers => [],
-    :coveredby => [ 3 ],
-    :crosses => [],
-    :disjoint => [ 1, 2 ],
-    :equals => [],
-    :intersects => [ 3 ],
-    :orderingequals => [],
-    :overlaps => [],
-    :touches => [],
-    :within => [ 3 ],
-    :'3dintersects' => [ 3 ]
+    contains: [],
+    containsproperly: [],
+    covers: [],
+    coveredby: [3],
+    crosses: [],
+    disjoint: [1, 2],
+    equals: [],
+    intersects: [3],
+    orderingequals: [],
+    overlaps: [],
+    touches: [],
+    within: [3],
+    :'3dintersects' => [3]
   }.each do |relationship, ids|
     define_method("test_#{relationship}") do
       skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
@@ -47,11 +53,11 @@ class RelationshipsTest < ActiveRecordSpatialTestCase
       Foo.reflections.delete(:bars)
 
       Foo.class_eval do
-        has_many_spatially :bars, :relationship => relationship
+        has_many_spatially :bars, relationship: relationship
       end
 
-      assert_equal(:has_many, Foo.reflections[:bars].macro)
-      assert_equal(relationship, Foo.reflections[:bars].options[:relationship])
+      assert_equal(:has_many, Foo.reflections[reflection_key(:bars)].macro)
+      assert_equal(relationship, Foo.reflections[reflection_key(:bars)].options[:relationship])
       assert_equal(ids, Foo.first.bars.collect(&:id).sort)
     end
   end
@@ -63,19 +69,19 @@ class RelationshipsWithSelfTest < ActiveRecordSpatialTestCase
   end
 
   {
-    :contains => [ 1 ],
-    :containsproperly => [ 1 ],
-    :covers => [ 1 ],
-    :coveredby => [ 1, 3 ],
-    :crosses => [],
-    :disjoint => [ 2 ],
-    :equals => [ 1 ],
-    :intersects => [ 1, 3 ],
-    :orderingequals => [ 1 ],
-    :overlaps => [],
-    :touches => [],
-    :within => [ 1, 3 ],
-    :'3dintersects' => [ 1, 3 ]
+    contains: [1],
+    containsproperly: [1],
+    covers: [1],
+    coveredby: [1, 3],
+    crosses: [],
+    disjoint: [2],
+    equals: [1],
+    intersects: [1, 3],
+    orderingequals: [1],
+    overlaps: [],
+    touches: [],
+    within: [1, 3],
+    :'3dintersects' => [1, 3]
   }.each do |relationship, ids|
     define_method("test_#{relationship}") do
       skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
@@ -83,11 +89,11 @@ class RelationshipsWithSelfTest < ActiveRecordSpatialTestCase
       Foo.reflections.delete(:foos)
 
       Foo.class_eval do
-        has_many_spatially :foos, :relationship => relationship
+        has_many_spatially :foos, relationship: relationship
       end
 
-      assert_equal(:has_many, Foo.reflections[:foos].macro)
-      assert_equal(relationship, Foo.reflections[:foos].options[:relationship])
+      assert_equal(:has_many, Foo.reflections[reflection_key(:foos)].macro)
+      assert_equal(relationship, Foo.reflections[reflection_key(:foos)].options[:relationship])
       assert_equal(ids, Foo.first.foos.collect(&:id).sort)
     end
   end
@@ -99,19 +105,19 @@ class RelationshipsWithForeignGeomTest < ActiveRecordSpatialTestCase
   end
 
   {
-    :contains => [],
-    :containsproperly => [],
-    :covers => [],
-    :coveredby => [ 3 ],
-    :crosses => [],
-    :disjoint => [ 1, 2 ],
-    :equals => [],
-    :intersects => [ 3 ],
-    :orderingequals => [],
-    :overlaps => [],
-    :touches => [],
-    :within => [ 3 ],
-    :'3dintersects' => [ 3 ]
+    contains: [],
+    containsproperly: [],
+    covers: [],
+    coveredby: [3],
+    crosses: [],
+    disjoint: [1, 2],
+    equals: [],
+    intersects: [3],
+    orderingequals: [],
+    overlaps: [],
+    touches: [],
+    within: [3],
+    :'3dintersects' => [3]
   }.each do |relationship, ids|
     define_method("test_#{relationship}") do
       skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
@@ -120,14 +126,14 @@ class RelationshipsWithForeignGeomTest < ActiveRecordSpatialTestCase
 
       Foo.class_eval do
         has_many_spatially :bars,
-          :relationship => relationship,
-          :foreign_geom => :the_other_geom
+          relationship: relationship,
+          foreign_geom: :the_other_geom
       end
 
-      assert_equal(:has_many, Foo.reflections[:bars].macro)
-      assert_equal(relationship, Foo.reflections[:bars].options[:relationship])
-      assert_equal(:the_geom, Foo.reflections[:bars].options[:geom])
-      assert_equal(:the_other_geom, Foo.reflections[:bars].options[:foreign_geom])
+      assert_equal(:has_many, Foo.reflections[reflection_key(:bars)].macro)
+      assert_equal(relationship, Foo.reflections[reflection_key(:bars)].options[:relationship])
+      assert_equal(:the_geom, Foo.reflections[reflection_key(:bars)].options[:geom])
+      assert_equal(:the_other_geom, Foo.reflections[reflection_key(:bars)].options[:foreign_geom])
       assert_equal(ids, Foo.first.bars.collect(&:id).sort)
     end
   end
@@ -139,19 +145,19 @@ class RelationshipsWithGeomTest < ActiveRecordSpatialTestCase
   end
 
   {
-    :contains => [],
-    :containsproperly => [],
-    :covers => [],
-    :coveredby => [ 3 ],
-    :crosses => [],
-    :disjoint => [ 1, 2 ],
-    :equals => [],
-    :intersects => [ 3 ],
-    :orderingequals => [],
-    :overlaps => [],
-    :touches => [ 3 ],
-    :within => [],
-    :'3dintersects' => [ 3 ]
+    contains: [],
+    containsproperly: [],
+    covers: [],
+    coveredby: [3],
+    crosses: [],
+    disjoint: [1, 2],
+    equals: [],
+    intersects: [3],
+    orderingequals: [],
+    overlaps: [],
+    touches: [3],
+    within: [],
+    :'3dintersects' => [3]
   }.each do |relationship, ids|
     define_method("test_#{relationship}") do
       skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
@@ -160,14 +166,14 @@ class RelationshipsWithGeomTest < ActiveRecordSpatialTestCase
 
       Foo.class_eval do
         has_many_spatially :bars,
-          :relationship => relationship,
-          :geom => :the_other_geom
+          relationship: relationship,
+          geom: :the_other_geom
       end
 
-      assert_equal(:has_many, Foo.reflections[:bars].macro)
-      assert_equal(relationship, Foo.reflections[:bars].options[:relationship])
-      assert_equal(:the_other_geom, Foo.reflections[:bars].options[:geom])
-      assert_equal(:the_geom, Foo.reflections[:bars].options[:foreign_geom])
+      assert_equal(:has_many, Foo.reflections[reflection_key(:bars)].macro)
+      assert_equal(relationship, Foo.reflections[reflection_key(:bars)].options[:relationship])
+      assert_equal(:the_other_geom, Foo.reflections[reflection_key(:bars)].options[:geom])
+      assert_equal(:the_geom, Foo.reflections[reflection_key(:bars)].options[:foreign_geom])
       assert_equal(ids, Foo.first.bars.collect(&:id).sort)
     end
   end
@@ -193,8 +199,8 @@ class WithCounterSqlTest < ActiveRecordSpatialTestCase
     assert_raise(ArgumentError) do
       Foo.class_eval do
         has_many_spatially :bars,
-          :class_name => 'Bar',
-          :counter_sql => "SELECT COUNT(*) bars.* FROM bars"
+          class_name: 'Bar',
+          counter_sql: 'SELECT COUNT(*) bars.* FROM bars'
       end
     end
   end
@@ -206,9 +212,9 @@ class ScopeOptionsTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :scope_options => {
-          :use_index => false
+        class_name: 'Bar',
+        scope_options: {
+          use_index: false
         }
     end
   end
@@ -235,7 +241,7 @@ class PreloadTest < ActiveRecordSpatialTestCase
       end
     end
 
-    assert_equal([ 1, 1, 2], values)
+    assert_equal([1, 1, 2], values)
   end
 
   def test_with_eager_loading
@@ -248,7 +254,7 @@ class PreloadTest < ActiveRecordSpatialTestCase
       end
     end
 
-    assert_equal([ 1, 1, 2 ], values)
+    assert_equal([1, 1, 2], values)
   end
 end
 
@@ -258,8 +264,8 @@ class PreloadWithOtherGeomTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :geom => :the_other_geom
+        class_name: 'Bar',
+        geom: :the_other_geom
     end
   end
 
@@ -273,7 +279,7 @@ class PreloadWithOtherGeomTest < ActiveRecordSpatialTestCase
       end
     end
 
-    assert_equal([ 1, 0, 2 ], values)
+    assert_equal([1, 0, 2], values)
   end
 
   def test_with_eager_loading
@@ -286,27 +292,7 @@ class PreloadWithOtherGeomTest < ActiveRecordSpatialTestCase
       end
     end
 
-    assert_equal([ 1, 0, 2 ], values)
-  end
-end
-
-class OrderingTest < ActiveRecordSpatialTestCase
-  def self.before_suite
-    load_models(:foo, :bar)
-
-    Foo.class_eval do
-      has_many_spatially :bars,
-        :relationship => :disjoint,
-        :order => 'ST_area(the_geom)'
-    end
-  end
-
-  def test_ordering
-    assert_equal([ 1, 2 ], Foo.first.bars.collect(&:id))
-  end
-
-  def test_reordering
-    assert_equal([ 2, 1 ], Foo.first.bars.reorder('bars.id DESC').collect(&:id))
+    assert_equal([1, 0, 2], values)
   end
 end
 
@@ -316,13 +302,13 @@ class PolymorphicAssociationsTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :zortables,
-        :as => :zortable
+        as: :zortable
     end
 
     Bar.class_eval do
       has_many_spatially :zortables,
-        :as => :zortable,
-        :geom => :the_other_geom
+        as: :zortable,
+        geom: :the_other_geom
     end
   end
 
@@ -334,7 +320,7 @@ class PolymorphicAssociationsTest < ActiveRecordSpatialTestCase
       end
     end
 
-    assert_equal([ 1, 7 ], values)
+    assert_equal([1, 7], values)
   end
 
   def test_without_eager_loading_and_geom
@@ -345,29 +331,35 @@ class PolymorphicAssociationsTest < ActiveRecordSpatialTestCase
       end
     end
 
-    assert_equal([ 6 ], values)
+    assert_equal([6], values)
   end
 
   def test_with_eager_loading
     values = nil
-    assert_queries(2) do
-      assert_sql(/SELECT "zortables"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "zortables" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\("__spatial_ids_join__"."the_geom", "zortables"."zortable_geom"\)\) WHERE "zortables"."zortable_type" = 'Foo' AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "zortables"\."id"/) do
-        values = Foo.includes(:zortables).first.zortables.collect(&:id).sort
+
+    Foo.connection.unprepared_statement do
+      assert_queries(2) do
+        assert_sql(/SELECT "zortables"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "zortables" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\("__spatial_ids_join__"."the_geom", "zortables"."zortable_geom"\)\) WHERE "zortables"."zortable_type" = 'Foo' AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "zortables"\."id"/) do
+          values = Foo.includes(:zortables).first.zortables.collect(&:id).sort
+        end
       end
     end
 
-    assert_equal([ 1, 7 ], values)
+    assert_equal([1, 7], values)
   end
 
   def test_with_eager_loading_and_geom
     values = nil
-    assert_queries(2) do
-      assert_sql(/SELECT "zortables"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "zortables" INNER JOIN "bars" AS "__spatial_ids_join__" ON \(ST_intersects\(ST_SetSRID\("__spatial_ids_join__"."the_other_geom", #{ActiveRecordSpatial::UNKNOWN_SRID}\), "zortables"."zortable_geom"\)\) WHERE "zortables"."zortable_type" = 'Bar' AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "zortables"\."id"/) do
-        values = Bar.includes(:zortables).first.zortables.collect(&:id).sort
+
+    Bar.connection.unprepared_statement do
+      assert_queries(2) do
+        assert_sql(/SELECT "zortables"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "zortables" INNER JOIN "bars" AS "__spatial_ids_join__" ON \(ST_intersects\(ST_SetSRID\("__spatial_ids_join__"."the_other_geom", #{ActiveRecordSpatial::UNKNOWN_SRID}\), "zortables"."zortable_geom"\)\) WHERE "zortables"."zortable_type" = 'Bar' AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "zortables"\."id"/) do
+          values = Bar.includes(:zortables).first.zortables.collect(&:id).sort
+        end
       end
     end
 
-    assert_equal([ 6 ], values)
+    assert_equal([6], values)
   end
 end
 
@@ -377,19 +369,19 @@ class PolymorphicAssociationsWithRelationshipsTest < ActiveRecordSpatialTestCase
   end
 
   {
-    :contains => [ 1 ],
-    :containsproperly => [ 1 ],
-    :covers => [ 1 ],
-    :coveredby => [ 1, 7 ],
-    :crosses => [],
-    :disjoint => [ 2, 3 ],
-    :equals => [ 1 ],
-    :intersects => [ 1, 7 ],
-    :orderingequals => [ 1 ],
-    :overlaps => [],
-    :touches => [],
-    :within => [ 1, 7 ],
-    :'3dintersects' => [ 1, 7 ]
+    contains: [1],
+    containsproperly: [1],
+    covers: [1],
+    coveredby: [1, 7],
+    crosses: [],
+    disjoint: [2, 3],
+    equals: [1],
+    intersects: [1, 7],
+    orderingequals: [1],
+    overlaps: [],
+    touches: [],
+    within: [1, 7],
+    :'3dintersects' => [1, 7]
   }.each do |relationship, ids|
     define_method("test_#{relationship}") do
       skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
@@ -398,8 +390,8 @@ class PolymorphicAssociationsWithRelationshipsTest < ActiveRecordSpatialTestCase
 
       Foo.class_eval do
         has_many_spatially :zortables,
-          :as => :zortable,
-          :relationship => relationship
+          as: :zortable,
+          relationship: relationship
       end
 
       assert_equal(ids, Foo.first.zortables.collect(&:id).sort)
@@ -414,62 +406,49 @@ class ClassNameOptionTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :blops,
-        :class_name => 'Bar'
+        class_name: 'Bar'
     end
   end
 
   def test_class_name
-    assert_equal([ 3 ], Foo.first.blops.collect(&:id))
-    assert_equal([ 3 ], Foo.includes(:blops).first.blops.collect(&:id))
+    assert_equal([3], Foo.first.blops.collect(&:id))
+    assert_equal([3], Foo.includes(:blops).first.blops.collect(&:id))
   end
 end
 
-class ConditionsOptionTest < ActiveRecordSpatialTestCase
+class ScopesTest < ActiveRecordSpatialTestCase
   def self.before_suite
     load_models(:foo, :bar)
 
     Foo.class_eval do
-      has_many_spatially :bars,
-        :relationship => :disjoint,
-        :conditions => {
-          :bars => {
-            :id => 3
-          }
-        }
+      has_many_spatially :bars, -> {
+        where(bars: { id: 3 })
+      }, relationship: :disjoint
     end
   end
 
-  def test_conditions
-    assert_equal([], Foo.first.bars.collect(&:id))
-    assert_equal([], Foo.includes(:bars).first.bars.collect(&:id))
-  end
-end
-
-class IncludeOptionTest < ActiveRecordSpatialTestCase
-  def self.before_suite
-    load_models(:blort, :foo, :bar)
+  def test_scopes_without_eager_loading
+    values = nil
 
-    Foo.class_eval do
-      has_many :blorts
+    Foo.connection.unprepared_statement do
+      assert_sql(/SELECT "bars".* FROM "bars"\s+WHERE \(ST_disjoint\('#{REGEXP_WKB_HEX}'::geometry, "bars"."the_geom"\)\) AND "bars"."id" = 3/) do
+        values = Foo.first.bars.collect(&:id)
+      end
     end
 
-    Bar.class_eval do
-      has_many_spatially :foos,
-        :include => :blorts
-    end
+    assert_equal([], values)
   end
 
-  def test_includes
-    skip("Removed from AR 4") if ActiveRecord::VERSION::MAJOR >= 4
-
+  def test_scopes_with_eager_loading
     values = nil
-    assert_queries(3) do
-      assert_sql(/SELECT\s+"blorts"\.\*\s+FROM\s+"blorts"\s+WHERE\s+"blorts"\."foo_id"\s+IN\s+\(.+\)/) do
-        values = Bar.first.foos.collect(&:id)
+
+    Foo.connection.unprepared_statement do
+      assert_sql(/SELECT "bars"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "bars" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_disjoint\("__spatial_ids_join__"."the_geom", "bars"."the_geom"\)\) WHERE "bars"."id" = 3 AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "bars"\."id"/) do
+        values = Foo.includes(:bars).first.bars.collect(&:id)
       end
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([], values)
   end
 end
 
@@ -479,9 +458,9 @@ class GeomWrapperTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :geom => {
-          :wrapper => :envelope
+        class_name: 'Bar',
+        geom: {
+          wrapper: :envelope
         }
     end
   end
@@ -493,7 +472,7 @@ class GeomWrapperTest < ActiveRecordSpatialTestCase
       values = Foo.first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 
   def test_with_eager_loading
@@ -503,7 +482,7 @@ class GeomWrapperTest < ActiveRecordSpatialTestCase
       values = Foo.includes(:bars).first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 end
 
@@ -513,9 +492,9 @@ class ForeignGeomWrapperTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :foreign_geom => {
-          :wrapper => :envelope
+        class_name: 'Bar',
+        foreign_geom: {
+          wrapper: :envelope
         }
     end
   end
@@ -527,7 +506,7 @@ class ForeignGeomWrapperTest < ActiveRecordSpatialTestCase
       values = Foo.first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 
   def test_with_eager_loading
@@ -537,7 +516,7 @@ class ForeignGeomWrapperTest < ActiveRecordSpatialTestCase
       values = Foo.includes(:bars).first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 end
 
@@ -547,12 +526,12 @@ class BothGeomWrapperTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :geom => {
-          :wrapper => :convexhull
+        class_name: 'Bar',
+        geom: {
+          wrapper: :convexhull
         },
-        :foreign_geom => {
-          :wrapper => :envelope
+        foreign_geom: {
+          wrapper: :envelope
         }
     end
   end
@@ -564,7 +543,7 @@ class BothGeomWrapperTest < ActiveRecordSpatialTestCase
       values = Foo.first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 
   def test_with_eager_loading
@@ -574,7 +553,7 @@ class BothGeomWrapperTest < ActiveRecordSpatialTestCase
       values = Foo.includes(:bars).first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 end
 
@@ -584,13 +563,13 @@ class BothGeomWrapperWithMixedSRIDsTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :geom => {
-          :wrapper => :convexhull
+        class_name: 'Bar',
+        geom: {
+          wrapper: :convexhull
         },
-        :foreign_geom => {
-          :wrapper => :centroid,
-          :name => :the_other_geom
+        foreign_geom: {
+          wrapper: :centroid,
+          name: :the_other_geom
         }
     end
   end
@@ -602,7 +581,7 @@ class BothGeomWrapperWithMixedSRIDsTest < ActiveRecordSpatialTestCase
       values = Foo.first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 
   def test_with_eager_loading
@@ -612,7 +591,7 @@ class BothGeomWrapperWithMixedSRIDsTest < ActiveRecordSpatialTestCase
       values = Foo.includes(:bars).first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 3 ], values)
+    assert_equal([3], values)
   end
 end
 
@@ -622,15 +601,15 @@ class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
 
     Foo.class_eval do
       has_many_spatially :bars,
-        :class_name => 'Bar',
-        :geom => {
-          :wrapper => :convexhull
+        class_name: 'Bar',
+        geom: {
+          wrapper: :convexhull
         },
-        :foreign_geom => {
-          :wrapper => {
-            :buffer => 100
+        foreign_geom: {
+          wrapper: {
+            buffer: 100
           },
-          :name => :the_other_geom
+          name: :the_other_geom
         }
     end
   end
@@ -642,7 +621,7 @@ class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
       values = Foo.first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 1, 2, 3 ], values)
+    assert_equal([1, 2, 3], values)
   end
 
   def test_with_eager_loading
@@ -652,7 +631,7 @@ class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
       values = Foo.includes(:bars).first.bars.collect(&:id).sort
     end
 
-    assert_equal([ 1, 2, 3 ], values)
+    assert_equal([1, 2, 3], values)
   end
 
   class ScopeArgumentTest < ActiveRecordSpatialTestCase
@@ -663,7 +642,7 @@ class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
     def test_foo
       Foo.class_eval do
         has_many_spatially :bars, proc {
-          self.order(:id)
+          order(:id)
         }
       end
 
@@ -671,6 +650,5 @@ class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
         Foo.first.bars.to_a
       end
     end
-  end if ActiveRecord::VERSION::MAJOR >= 4
+  end
 end
-