activerecord-spatial 0.0.1

data/test/database.yml

@@ -0,0 +1,17 @@
+---
+# To modify the test database parameters, create a new file called
+# local_database.yml and go nuts with settings. The "jdbc" settings
+# are merged into the "arunit" settings as JDBC works over a TCP
+# socket and those sorts of connections generally require some user
+# credentials.
+
+arunit:
+  adapter: "postgresql"
+  database: "activerecord_spatial_unit_tests"
+  min_messages: "warning"
+  schema_search_path: "public"
+
+jdbc:
+  host: "localhost"
+  adapter: "jdbcpostgresql"
+

data/test/fixtures/bars.yml

@@ -0,0 +1,16 @@
+---
+bars_1:
+  id: 1
+  name: "one"
+  the_geom: 'POINT(5 5)'
+  the_other_geom: 'SRID=4326; POINT(15 15)'
+bars_2:
+  id: 2
+  name: "two"
+  the_geom: 'POINT(15 15)'
+  the_other_geom: 'SRID=4326; POINT(25 25)'
+bars_3:
+  id: 3
+  name: "three"
+  the_geom: 'POLYGON((-10 -10, -10 10, 10 10, 10 -10, -10 -10))'
+  the_other_geom: 'SRID=4326; POLYGON((-10 -10, -10 10, 10 10, 10 -10, -10 -10))'

data/test/fixtures/blorts.yml

@@ -0,0 +1,37 @@
+---
+blorts_1:
+  id: 1
+  name: "foo 1-1"
+  foo_id: 1
+blorts_2:
+  id: 2
+  name: "foo 1-2"
+  foo_id: 1
+blorts_3:
+  id: 3
+  name: "foo 1-3"
+  foo_id: 1
+blorts_4:
+  id: 4
+  name: "foo 2-1"
+  foo_id: 2
+blorts_5:
+  id: 5
+  name: "foo 2-2"
+  foo_id: 2
+blorts_6:
+  id: 6
+  name: "foo 2-3"
+  foo_id: 2
+blorts_7:
+  id: 7
+  name: "foo 3-1"
+  foo_id: 3
+blorts_8:
+  id: 8
+  name: "foo 3-2"
+  foo_id: 3
+blorts_9:
+  id: 9
+  name: "foo 3-3"
+  foo_id: 3

data/test/fixtures/foo3ds.yml

@@ -0,0 +1,17 @@
+---
+one:
+  id: 1
+  name: "one"
+  the_geom: 'POINT(0 0 0)'
+  the_other_geom: 'SRID=4326; POINT(10 10 10)'
+two:
+  id: 2
+  name: "two"
+  the_geom: 'POINT(10 10 10)'
+  the_other_geom: 'SRID=4326; POINT(20 20 20)'
+three:
+  id: 3
+  name: "three"
+  the_geom: 'POLYGON((-5 -5 -5, -5 5 5, 5 5 5, 5 -5 -5, -5 -5 -5))'
+  the_other_geom: 'SRID=4326; POLYGON((5 5 5, 5 10 10, 10 10 10, 10 5 5, 5 5 5))'
+

data/test/fixtures/foo_geographies.yml

@@ -0,0 +1,16 @@
+---
+one:
+  id: 1
+  name: "one"
+  the_geom: 'POINT(0 0)'
+  the_other_geom: 'SRID=4326; POINT(10 10)'
+two:
+  id: 2
+  name: "two"
+  the_geom: 'POINT(10 10)'
+  the_other_geom: 'SRID=4326; POINT(20 20)'
+three:
+  id: 3
+  name: "three"
+  the_geom: 'POLYGON((-5 -5, -5 5, 5 5, 5 -5, -5 -5))'
+  the_other_geom: 'SRID=4326; POLYGON((5 5, 5 10, 10 10, 10 5, 5 5))'

data/test/fixtures/foos.yml

@@ -0,0 +1,16 @@
+---
+foos_1:
+  id: 1
+  name: "one"
+  the_geom: 'POINT(0 0)'
+  the_other_geom: 'SRID=4326; POINT(10 10)'
+foos_2:
+  id: 2
+  name: "two"
+  the_geom: 'POINT(10 10)'
+  the_other_geom: 'SRID=4326; POINT(20 20)'
+foos_3:
+  id: 3
+  name: "three"
+  the_geom: 'POLYGON((-5 -5, -5 5, 5 5, 5 -5, -5 -5))'
+  the_other_geom: 'SRID=4326; POLYGON((5 5, 5 10, 10 10, 10 5, 5 5))'

data/test/fixtures/zortables.yml

@@ -0,0 +1,36 @@
+---
+zortable_1:
+  id: 1
+  name: "zortable 1-1"
+  zortable_geom: "010100000000000000000000000000000000000000"
+  zortable_type: "Foo"
+zortable_2:
+  id: 2
+  name: "zortable 1-2"
+  zortable_geom: "010100000000000000000014400000000000001440"
+  zortable_type: "Foo"
+zortable_3:
+  id: 3
+  name: "zortable 1-3"
+  zortable_geom: "01010000000000000000002E400000000000002E40"
+  zortable_type: "Foo"
+zortable_4:
+  id: 4
+  name: "zortable 2-1"
+  zortable_geom: "010100000000000000000000000000000000000000"
+  zortable_type: "Bar"
+zortable_5:
+  id: 5
+  name: "zortable 2-2"
+  zortable_geom: "010100000000000000000014400000000000001440"
+  zortable_type: "Bar"
+zortable_6:
+  id: 6
+  name: "zortable 2-3"
+  zortable_geom: "01010000000000000000002E400000000000002E40"
+  zortable_type: "Bar"
+zortable_7:
+  id: 7
+  name: "big zortable"
+  zortable_geom: "0103000000010000000500000000000000000034C000000000000034C000000000000034C0000000000000344000000000000034400000000000003440000000000000344000000000000034C000000000000034C000000000000034C0"
+  zortable_type: "Foo"

data/test/geography_column_tests.rb

@@ -0,0 +1,40 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeographyColumnTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo_geography)
+  end
+
+  def test_geography_columns_detected
+    assert_equal(0, FooGeography.geometry_columns.length)
+    assert_equal(2, FooGeography.geography_columns.length)
+
+    FooGeography.geography_columns.each do |column|
+      assert_kind_of(ActiveRecordSpatial::GeographyColumn, column)
+    end
+  end
+
+  def test_srid_for
+    assert_equal(ActiveRecordSpatial::UNKNOWN_SRIDS[:geography], FooGeography.srid_for(:the_geom))
+    assert_equal(4326, FooGeography.srid_for(:the_other_geom))
+  end
+
+  def test_coord_dimension_for
+    assert_equal(2, FooGeography.coord_dimension_for(:the_geom))
+    assert_equal(2, FooGeography.coord_dimension_for(:the_other_geom))
+  end
+
+  def test_geography_column_by_name
+    assert_kind_of(ActiveRecordSpatial::GeographyColumn, FooGeography.geography_column_by_name(:the_geom))
+    assert_kind_of(ActiveRecordSpatial::GeographyColumn, FooGeography.geography_column_by_name(:the_other_geom))
+  end
+
+  def test_spatial_ref_sys
+    assert_nil(FooGeography.geography_column_by_name(:the_geom).spatial_ref_sys)
+    assert_kind_of(ActiveRecordSpatial::SpatialRefSys, FooGeography.geography_column_by_name(:the_other_geom).spatial_ref_sys)
+    assert_equal(4326, FooGeography.geography_column_by_name(:the_other_geom).spatial_ref_sys.srid)
+  end
+end
+

data/test/geometry_column_tests.rb

@@ -0,0 +1,40 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeometryColumnTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo)
+  end
+
+  def test_geometry_columns_detected
+    assert_equal(2, Foo.geometry_columns.length)
+    assert_equal(0, Foo.geography_columns.length)
+
+    Foo.geometry_columns.each do |column|
+      assert_kind_of(ActiveRecordSpatial::GeometryColumn, column)
+    end
+  end
+
+  def test_srid_for
+    assert_equal(ActiveRecordSpatial::UNKNOWN_SRID, Foo.srid_for(:the_geom))
+    assert_equal(4326, Foo.srid_for(:the_other_geom))
+  end
+
+  def test_coord_dimension_for
+    assert_equal(2, Foo.coord_dimension_for(:the_geom))
+    assert_equal(2, Foo.coord_dimension_for(:the_other_geom))
+  end
+
+  def test_geometry_column_by_name
+    assert_kind_of(ActiveRecordSpatial::GeometryColumn, Foo.geometry_column_by_name(:the_geom))
+    assert_kind_of(ActiveRecordSpatial::GeometryColumn, Foo.geometry_column_by_name(:the_other_geom))
+  end
+
+  def test_spatial_ref_sys
+    assert_nil(Foo.geometry_column_by_name(:the_geom).spatial_ref_sys)
+    assert_kind_of(ActiveRecordSpatial::SpatialRefSys, Foo.geometry_column_by_name(:the_other_geom).spatial_ref_sys)
+    assert_equal(4326, Foo.geometry_column_by_name(:the_other_geom).spatial_ref_sys.srid)
+  end
+end
+

data/test/models/bar.rb

@@ -0,0 +1,17 @@
+
+if !ARBC.table_exists?('bars')
+  ActiveRecord::Migration.create_table(:bars) do |t|
+    t.text :name
+  end
+
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'bars', 'the_geom', #{ActiveRecordSpatial::UNKNOWN_SRID}, 'GEOMETRY', 2)})
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'bars', 'the_other_geom', 4326, 'GEOMETRY', 2)})
+end
+
+class Bar < ActiveRecord::Base
+  include ActiveRecordSpatial::SpatialColumns
+  include ActiveRecordSpatial::SpatialScopes
+
+  self.create_spatial_column_accessors!
+end
+

data/test/models/blort.rb

@@ -0,0 +1,12 @@
+
+if !ARBC.table_exists?('blorts')
+  ActiveRecord::Migration.create_table(:blorts) do |t|
+    t.text :name
+    t.integer :foo_id
+  end
+end
+
+class Blort < ActiveRecord::Base
+  belongs_to :foo
+end
+

data/test/models/foo.rb

@@ -0,0 +1,17 @@
+
+if !ARBC.table_exists?('foos')
+  ActiveRecord::Migration.create_table(:foos) do |t|
+    t.text :name
+  end
+
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'foos', 'the_geom', #{ActiveRecordSpatial::UNKNOWN_SRID}, 'GEOMETRY', 2)})
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'foos', 'the_other_geom', 4326, 'GEOMETRY', 2)})
+end
+
+class Foo < ActiveRecord::Base
+  include ActiveRecordSpatial::SpatialColumns
+  include ActiveRecordSpatial::SpatialScopes
+
+  self.create_spatial_column_accessors!
+end
+

data/test/models/foo3d.rb

@@ -0,0 +1,17 @@
+
+if !ARBC.table_exists?('foo3ds')
+  ActiveRecord::Migration.create_table(:foo3ds) do |t|
+    t.text :name
+  end
+
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'foo3ds', 'the_geom', #{ActiveRecordSpatial::UNKNOWN_SRID}, 'GEOMETRY', 3)})
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'foo3ds', 'the_other_geom', 4326, 'GEOMETRY', 3)})
+end
+
+class Foo3d < ActiveRecord::Base
+  include ActiveRecordSpatial::SpatialColumns
+  include ActiveRecordSpatial::SpatialScopes
+
+  self.create_spatial_column_accessors!
+end
+

data/test/models/foo_geography.rb

@@ -0,0 +1,16 @@
+
+if !ARBC.table_exists?('foo_geographies')
+  ActiveRecord::Migration.create_table(:foo_geographies) do |t|
+    t.text :name
+    t.column :the_geom, :geography
+    t.column :the_other_geom, 'geography(Geometry, 4326)'
+  end
+end
+
+class FooGeography < ActiveRecord::Base
+  include ActiveRecordSpatial::SpatialColumns
+  include ActiveRecordSpatial::SpatialScopes
+
+  self.create_spatial_column_accessors!
+end
+

data/test/models/zortable.rb

@@ -0,0 +1,17 @@
+
+if !ARBC.table_exists?('zortables')
+  ActiveRecord::Migration.create_table(:zortables) do |t|
+    t.text :name
+    t.text :zortable_type
+  end
+
+  ARBC.execute(%{SELECT AddGeometryColumn('public', 'zortables', 'zortable_geom', #{ActiveRecordSpatial::UNKNOWN_SRID}, 'GEOMETRY', 2)})
+end
+
+class Zortable < ActiveRecord::Base
+  include ActiveRecordSpatial::SpatialColumns
+  include ActiveRecordSpatial::SpatialScopes
+
+  self.create_spatial_column_accessors!
+end
+

data/test/spatial_scopes_geographies_tests.rb

@@ -0,0 +1,106 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class SpatialScopesGeographiesTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo_geography)
+  end
+
+  def ids_tester(method, args, ids = [], options = {})
+    geoms = FooGeography.send(method, *Array.wrap(args)).all(options)
+    assert_equal(ids.sort, geoms.collect(&:id).sort)
+  end
+
+  def test_covers
+    ids_tester(:st_covers, 'POINT(0 0)', [ 3 ], :conditions => {
+      :id => [ 3 ]
+    })
+  end
+
+  def test_coveredby
+    ids_tester(:st_coveredby, 'POLYGON((-6 -6, -6 6, 6 6, 6 -6, -6 -6))', [ 1 ], :conditions => {
+      :id => [ 1, 2 ]
+    })
+  end
+
+  def test_intersects
+    ids_tester(:st_intersects, 'LINESTRING(-5 -5, 10 10)', [ 2, 3 ])
+  end
+
+  def test_dwithin
+    ids_tester(:st_dwithin, [ 'POINT(5 5)', 10 ], [ 3 ])
+  end
+
+  def test_allow_null
+    begin
+      foo = FooGeography.create(:name => 'four')
+      ids_tester(:st_covers, [ 'POINT(3 3)', { :allow_null => true } ], [ 3, foo.id ])
+    ensure
+      FooGeography.find_by_name('four').destroy
+    end
+  end
+
+  def test_with_column
+    assert_equal([3], FooGeography.st_covers('POINT(7 7)', :column => :the_other_geom).all.collect(&:id).sort)
+  end
+
+  def test_with_srid_switching
+    assert_equal([3], FooGeography.st_covers('SRID=4326; POINT(3 3)').all.collect(&:id).sort)
+  end
+
+  def test_with_srid_default
+    assert_equal([3], FooGeography.st_covers('SRID=default; POINT(3 3)').all.collect(&:id).sort)
+  end
+
+  def test_with_srid_transform
+    assert_equal([3], FooGeography.st_covers('SRID=4269; POINT(7 7)', :column => :the_other_geom).all.collect(&:id).sort)
+  end
+
+  def test_order_by_st_distance
+    assert_equal([3, 1, 2], FooGeography.order_by_st_distance('POINT(1 1)').all.collect(&:id))
+  end
+
+  def test_order_by_st_distance_desc
+    assert_equal([2, 1, 3], FooGeography.order_by_st_distance('POINT(1 1)', :desc => true).all.collect(&:id))
+  end
+
+  def test_order_by_st_area
+    assert_equal([1, 2, 3], FooGeography.order_by_st_area.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_area_desc
+    assert_equal([3, 1, 2], FooGeography.order_by_st_area(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length
+    assert_equal([1, 2, 3], FooGeography.order_by_st_length.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length_desc
+    expected = if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
+      [1, 2, 3]
+    else
+      [3, 1, 2]
+    end
+
+    assert_equal(expected, FooGeography.order_by_st_length(:desc => true).order('id').where('true = true').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter
+    skip('requires PostGIS 2+') unless FooGeography.respond_to?(:order_by_st_perimeter)
+
+    assert_equal([1, 2, 3], FooGeography.order_by_st_perimeter.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter_desc
+    skip('requires PostGIS 2+') unless FooGeography.respond_to?(:order_by_st_perimeter)
+
+    assert_equal([3, 1, 2], FooGeography.order_by_st_perimeter(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_area_with_desc_symbol
+    assert_equal([3, 1, 2], FooGeography.order_by_st_area(:desc).order('id').all.collect(&:id))
+  end
+end
+