geos-extensions 0.1.6 → 0.2.0

data/lib/geos/active_record_extensions/{geospatial_scopes.rb → spatial_scopes.rb}

@@ -87,18 +87,24 @@ module Geos
     #
     # == SRID Detection
     #
+    # * the default SRID according to the SQL-MM standard is 0, but versions
+    #   of PostGIS prior to 2.0 would return -1. We do some detection here
+    #   and set the value of Geos::ActiveRecord.UNKNOWN_SRIDS[type]
+    #   accordingly.
     # * if the geometry itself has an SRID, we'll compare it to the
     #   geometry of the column. If they differ, we'll use ST_Transform
     #   to transform the geometry to the proper SRID for comparison. If
     #   they're the same, no conversion is necessary.
     # * if no SRID is specified in the geometry, we'll use ST_SetSRID
     #   to set the SRID to the column's SRID.
-    # * in cases where the column has been defined with an SRID of -1
-    #   (PostGIS's default), no transformation is done, but we'll set the
-    #   SRID of the geometry to -1 to perform the query using ST_SetSRID,
-    #   as we'll assume the SRID of the column to be whatever the SRID of
-    #   the geometry is.
-    module GeospatialScopes
+    # * in cases where the column has been defined with an SRID of
+    #   UNKNOWN_SRIDS[type], no transformation is done, but we'll set the SRID
+    #   of the geometry to UNKNOWN_SRIDS[type] to perform the query using
+    #   ST_SetSRID, as we'll assume the SRID of the column to be whatever
+    #   the SRID of the geometry is.
+    # * when using geography types, the SRID is never transformed since
+    #   it's assumed that all of your geometries will be in 4326.
+    module SpatialScopes
       SCOPE_METHOD = if ::ActiveRecord::VERSION::MAJOR >= 3
         'scope'
       else
@@ -118,7 +124,7 @@ module Geos
         overlaps
         touches
         within
-      }.freeze
+      }
 
       ZERO_ARGUMENT_MEASUREMENTS = %w{
         area
@@ -129,12 +135,10 @@ module Geos
         numinteriorring
         numinteriorrings
         numpoints
-        length3d
         length
         length2d
         perimeter
         perimeter2d
-        perimeter3d
       }
 
       ONE_GEOMETRY_ARGUMENT_MEASUREMENTS = %w{
@@ -150,23 +154,85 @@ module Geos
 
       ONE_ARGUMENT_MEASUREMENTS = %w{
         length2d_spheroid
-        length3d_spheroid
         length_spheroid
       }
 
+      # Some functions were renamed in PostGIS 2.0.
+      if Geos::ActiveRecord.POSTGIS[:lib] >= '2.0'
+        RELATIONSHIPS.concat(%w{
+          3dintersects
+        })
+
+        ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
+          3dlength
+          3dperimeter
+        })
+
+        ONE_ARGUMENT_MEASUREMENTS.concat(%w{
+          3dlength_spheroid
+        })
+
+        ONE_GEOMETRY_ARGUMENT_MEASUREMENTS.concat(%w{
+          3ddistance
+          3dmaxdistance
+        })
+
+        ONE_GEOMETRY_ARGUMENT_AND_ONE_ARGUMENT_RELATIONSHIPS.concat(%w{
+          3ddwithin
+          3ddfullywithin
+        })
+      else
+        ZERO_ARGUMENT_MEASUREMENTS.concat(%w{
+          length3d
+          perimeter3d
+        })
+
+        ONE_ARGUMENT_MEASUREMENTS.concat(%w{
+          length3d_spheroid
+        })
+      end
+
+      FUNCTION_ALIASES = {
+        'order_by_max_distance' => 'order_by_maxdistance',
+        'st_geometrytype' => 'st_geometry_type'
+      }
+
+      COMPATIBILITY_FUNCTION_ALIASES = if Geos::ActiveRecord.POSTGIS[:lib] >= '2.0'
+        {
+          'order_by_length3d' => 'order_by_3dlength',
+          'order_by_perimeter3d' => 'order_by_3dperimeter',
+          'order_by_length3d_spheroid' => 'order_by_3dlength_spheroid'
+        }
+      else
+        {
+          'order_by_3dlength' => 'order_by_length3d',
+          'order_by_3dperimeter' => 'order_by_perimeter3d',
+          'order_by_3dlength_spheroid' => 'order_by_length3d_spheroid'
+        }
+      end
+
+      if Geos::ActiveRecord.POSTGIS[:lib] >= '2.0'
+        FUNCTION_ALIASES.merge!({
+          'st_3d_dwithin' => 'st_3ddwithin',
+          'st_3d_dfully_within' => 'st_3ddfullywithin',
+          'order_by_3d_distance' => 'order_by_3ddistance',
+          'order_by_3d_max_distance' => 'order_by_3dmaxdistance'
+        })
+      end
+
       def self.included(base)
         base.class_eval do
           class << self
             protected
-              def set_srid_or_transform(column_srid, geom_srid, geos)
-                sql = if column_srid != geom_srid
-                  if column_srid == -1 || geom_srid == -1
-                    %{ST_SetSRID(?, #{column_srid})}
+              def set_srid_or_transform(column_srid, geom_srid, geos, type)
+                sql = if type != :geography && column_srid != geom_srid
+                  if column_srid == Geos::ActiveRecord.UNKNOWN_SRIDS[type] || geom_srid == Geos::ActiveRecord.UNKNOWN_SRIDS[type]
+                    %{ST_SetSRID(?::#{type}, #{column_srid})}
                   else
-                    %{ST_Transform(?, #{column_srid})}
+                    %{ST_Transform(?::#{type}, #{column_srid})}
                   end
                 else
-                  %{?}
+                  %{?::#{type}}
                 end
 
                 sanitize_sql([ sql, geos.to_ewkb ])
@@ -179,9 +245,9 @@ module Geos
                 Geos.read(geom)
               end
 
-              def read_geom_srid(geos)
-                if geos.srid == 0
-                  -1
+              def read_geom_srid(geos, column_type = :geometry)
+                if geos.srid == 0 || geos.srid == -1
+                  Geos::ActiveRecord.UNKNOWN_SRIDS[column_type]
                 else
                   geos.srid
                 end
@@ -223,12 +289,13 @@ module Geos
                   ret << "#{function_name(function, options[:use_index])}(#{self.quoted_table_name}.#{column_name}"
 
                   if geom
+                    column_type = self.spatial_column_by_name(options[:column]).spatial_type
                     column_srid = self.srid_for(options[:column])
 
                     geos = read_geos(geom, column_srid)
-                    geom_srid = read_geom_srid(geos)
+                    geom_srid = read_geom_srid(geos, column_type)
 
-                    ret << %{, #{self.set_srid_or_transform(column_srid, geom_srid, geos)}}
+                    ret << %{, #{self.set_srid_or_transform(column_srid, geom_srid, geos, column_type)}}
                   end
 
                   ret << ', ?' * function_options[:additional_args]
@@ -407,8 +474,18 @@ module Geos
               ])
             }
           })
+
+          class << base
+            aliases = COMPATIBILITY_FUNCTION_ALIASES.merge(FUNCTION_ALIASES)
+
+            aliases.each do |k, v|
+              alias_method(k, v)
+            end
+          end
         end
       end
     end
+
+    GeospatialScopes = SpatialScopes
   end
 end

data/lib/geos/active_record_extensions.rb

@@ -3,8 +3,10 @@ require File.join(Geos::GEOS_EXTENSIONS_BASE, *%w{ geos active_record_extensions
 
 module Geos
   module ActiveRecord
-    autoload :GeometryColumns, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions geometry_columns })
-    autoload :GeospatialScopes, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions geospatial_scopes })
+    autoload :SpatialColumns, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions spatial_columns })
+    autoload :GeometryColumns, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions spatial_columns })
+    autoload :SpatialScopes, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions spatial_scopes })
+    autoload :GeospatialScopes, File.join(Geos::GEOS_EXTENSIONS_BASE, %w{ geos active_record_extensions spatial_scopes })
   end
 end
 

data/test/adapter_tests.rb

@@ -19,5 +19,20 @@ if ENV['TEST_ACTIVERECORD']
       assert_equal(2, geometry_columns.length)
       assert_equal(2, other_columns.length)
     end
+
+    if Geos::ActiveRecord.geography_columns?
+      def test_simplified_type_geography
+        geography_columns = FooGeography.columns.select do |c|
+          c.type == :geography
+        end
+
+        other_columns = FooGeography.columns.select do |c|
+          c.type != :geography
+        end
+
+        assert_equal(2, geography_columns.length)
+        assert_equal(2, other_columns.length)
+      end
+    end
   end
 end

data/test/fixtures/foo3ds.yml

@@ -0,0 +1,16 @@
+---
+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/geography_columns_tests.rb

@@ -0,0 +1,176 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+if ENV['TEST_ACTIVERECORD']
+  class GeographyColumnsTests < ActiveRecord::TestCase
+    include TestHelper
+    include ActiveRecord::TestFixtures
+
+    self.fixture_path = File.join(File.dirname(__FILE__), 'fixtures')
+    fixtures :foo_geographies
+
+    def test_geography_columns_detected
+      assert_equal(2, FooGeography.geography_columns.length)
+
+      FooGeography.geography_columns.each do |column|
+        assert_kind_of(ActiveRecord::ConnectionAdapters::PostgreSQLSpatialColumn, column)
+      end
+    end
+
+    def test_srid_for
+      assert_equal(0, 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(ActiveRecord::ConnectionAdapters::PostgreSQLSpatialColumn, FooGeography.geography_column_by_name(:the_geom))
+      assert_kind_of(ActiveRecord::ConnectionAdapters::PostgreSQLSpatialColumn, FooGeography.geography_column_by_name(:the_other_geom))
+    end
+
+    def test_accessors
+      foo = FooGeography.find(1)
+
+      Geos::ActiveRecord::SpatialColumns::SPATIAL_COLUMN_OUTPUT_FORMATS.each do |format|
+        assert(foo.respond_to?("the_geom_#{format}"))
+        assert(foo.respond_to?("the_other_geom_#{format}"))
+      end
+    end
+
+    def test_without_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom)
+    end
+
+    def test_geos_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(Geos::Point, foo.the_geom_geos)
+    end
+
+    def test_wkt_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom_wkt)
+      assert_match(/^POINT\s*\(0\.0+\s+0\.0+\)$/, foo.the_geom_wkt)
+    end
+
+    def test_wkb_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom_wkb)
+      assert_match(/^[A-F0-9]+$/, foo.the_geom_wkb)
+    end
+
+    def test_ewkt_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom_ewkt)
+      assert_match(/^SRID=\d+;POINT\s*\(0\.0+\s+0\.0+\)$/, foo.the_geom_ewkt)
+    end
+
+    def test_ewkb_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom_ewkb)
+      assert(/^[A-F0-9]+$/, foo.the_geom_wkb)
+    end
+
+    def test_wkb_bin_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom_wkb_bin)
+    end
+
+    def test_ewkb_bin_accessor
+      foo = FooGeography.find(1)
+      assert_kind_of(String, foo.the_geom_ewkb_bin)
+    end
+
+    def test_geos_create
+      foo = FooGeography.create!(
+        :name => 'test_geos_create',
+        :the_geom => Geos.read(POINT_WKT)
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_geom_geos)
+    end
+
+    def test_wkt_create
+      foo = FooGeography.create!(
+        :name => 'test_wkt_create',
+        :the_geom => POINT_WKT
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_geom_geos)
+    end
+
+    def test_wkb_create
+      foo = FooGeography.create!(
+        :name => 'test_wkb_create',
+        :the_geom => POINT_WKB
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_geom_geos)
+    end
+
+    def test_ewkt_create_with_srid_4326
+      foo = FooGeography.create!(
+        :name => 'test_ewkt_create_with_srid_4326',
+        :the_other_geom => POINT_EWKT
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_other_geom_geos)
+    end
+
+    def test_create_with_no_srid_converting_to_4326
+      foo = FooGeography.create!(
+        :name => 'test_ewkt_create_with_no_srid_converting_to_4326',
+        :the_other_geom => POINT_WKT
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_other_geom_geos)
+    end
+
+    def test_create_with_no_srid_converting_to_minus_1
+      foo = FooGeography.create!(
+        :name => 'test_ewkt_create_with_no_srid_converting_to_minus_1',
+        :the_geom => POINT_EWKT
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_geom_geos)
+    end
+
+    def test_create_with_converting_from_900913_to_4326
+      foo = FooGeography.create!(
+        :name => 'test_create_with_converting_from_900913_to_4326',
+        :the_other_geom => "SRID=900913; #{POINT_WKT}"
+      )
+    end
+
+    def test_ewkt_create_with_srid_default
+      foo = FooGeography.create!(
+        :name => 'test_ewkt_create_with_srid_default',
+        :the_other_geom => POINT_EWKT_WITH_DEFAULT
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_other_geom_geos)
+    end
+
+    def test_ewkb_create
+      foo = FooGeography.create!(
+        :name => 'test_ewkb_create',
+        :the_other_geom => POINT_EWKB
+      )
+
+      foo.reload
+      assert_saneness_of_point(foo.the_other_geom_geos)
+    end
+  end
+end

data/test/geometry_columns_tests.rb

@@ -19,7 +19,7 @@ if ENV['TEST_ACTIVERECORD']
     end
 
     def test_srid_for
-      assert_equal(-1, Foo.srid_for(:the_geom))
+      assert_equal(Geos::ActiveRecord.UNKNOWN_SRID, Foo.srid_for(:the_geom))
       assert_equal(4326, Foo.srid_for(:the_other_geom))
     end
 
@@ -36,7 +36,7 @@ if ENV['TEST_ACTIVERECORD']
     def test_accessors
       foo = Foo.find(1)
 
-      Geos::ActiveRecord::GeometryColumns::GEOMETRY_COLUMN_OUTPUT_FORMATS.each do |format|
+      Geos::ActiveRecord::SpatialColumns::SPATIAL_COLUMN_OUTPUT_FORMATS.each do |format|
         assert(foo.respond_to?("the_geom_#{format}"))
         assert(foo.respond_to?("the_other_geom_#{format}"))
       end