activerecord-postgis-adapter 0.2.3 → 0.3.0

data/lib/active_record/connection_adapters/postgis_adapter/spatial_table_definition.rb

@@ -0,0 +1,136 @@
+# -----------------------------------------------------------------------------
+# 
+# PostGIS adapter for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+# :stopdoc:
+
+module ActiveRecord
+  
+  module ConnectionAdapters
+    
+    module PostGISAdapter
+      
+      
+      class SpatialTableDefinition < ConnectionAdapters::TableDefinition
+        
+        def column(name_, type_, options_={})
+          if (info_ = @base.spatial_column_constructor(type_.to_sym))
+            options_[:type] ||= info_[:type] || type_
+            type_ = :spatial
+          end
+          super(name_, type_, options_)
+          if type_ == :spatial
+            col_ = self[name_]
+            col_.extend(SpatialColumnDefinitionMethods) unless col_.respond_to?(:geographic?)
+            options_.merge!(col_.limit) if col_.limit.is_a?(::Hash)
+            col_.set_spatial_type(options_[:type])
+            col_.set_geographic(options_[:geographic])
+            col_.set_srid((options_[:srid] || 4326).to_i)
+            col_.set_has_z(options_[:has_z])
+            col_.set_has_m(options_[:has_m])
+          end
+          self
+        end
+        
+        def to_sql
+          @columns.find_all{ |c_| !c_.respond_to?(:geographic?) || c_.geographic? }.map{ |c_| c_.to_sql } * ', '
+        end
+        
+        def non_geographic_spatial_columns
+          @columns.find_all{ |c_| c_.respond_to?(:geographic?) && !c_.geographic? }
+        end
+        
+      end
+      
+      
+      module SpatialColumnDefinitionMethods
+        
+        def spatial_type
+          defined?(@spatial_type) && @spatial_type
+        end
+        
+        def geographic?
+          defined?(@geographic) && @geographic
+        end
+        
+        def srid
+          defined?(@srid) ? @srid : 4326
+        end
+        
+        def has_z?
+          defined?(@has_z) && @has_z
+        end
+        
+        def has_m?
+          defined?(@has_m) && @has_m
+        end
+        
+        def set_geographic(value_)
+          @geographic = value_ ? true : false
+        end
+        
+        def set_spatial_type(value_)
+          @spatial_type = value_.to_s
+        end
+        
+        def set_srid(value_)
+          @srid = value_
+        end
+        
+        def set_has_z(value_)
+          @has_z = value_ ? true : false
+        end
+        
+        def set_has_m(value_)
+          @has_m = value_ ? true : false
+        end
+        
+        def sql_type
+          type_ = spatial_type.upcase.gsub('_', '')
+          type_ << 'Z' if has_z?
+          type_ << 'M' if has_m?
+          "GEOGRAPHY(#{type_},#{srid})"
+        end
+        
+      end
+      
+      
+    end
+    
+  end
+  
+end
+
+# :startdoc:

data/lib/active_record/connection_adapters/postgis_adapter/version.rb

@@ -0,0 +1,62 @@
+# -----------------------------------------------------------------------------
+# 
+# PostGIS adapter for ActiveRecord
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+begin
+  require 'versionomy'
+rescue ::LoadError
+end
+
+
+module ActiveRecord
+  
+  module ConnectionAdapters
+    
+    module PostGISAdapter
+      
+      
+      # Current version of PostGISAdapter as a frozen string
+      VERSION_STRING = ::File.read(::File.dirname(__FILE__)+'/../../../../Version').strip.freeze
+      
+      # Current version of PostGISAdapter as a Versionomy object, if the
+      # Versionomy gem is available; otherwise equal to VERSION_STRING.
+      VERSION = defined?(::Versionomy) ? ::Versionomy.parse(VERSION_STRING) : VERSION_STRING
+      
+      
+    end
+    
+  end
+  
+end

data/lib/rgeo/active_record/postgis_adapter/railtie.rb

@@ -34,25 +34,6 @@
 ;
 
 
-require 'rails/railtie'
+puts "WARNING: rgeo/active_record/postgis_adapter/railtie is deprecated. Please use active_record/connection_adapters/postgis_adapter/railtie."
 
-
-module RGeo
-  
-  module ActiveRecord
-    
-    module PostgisAdapter
-      
-      class Railtie < ::Rails::Railtie
-        
-        rake_tasks do
-          load "rgeo/active_record/postgis_adapter/databases.rake"
-        end
-        
-      end
-      
-    end
-    
-  end
-  
-end
+require 'active_record/connection_adapters/postgis_adapter/railtie'

data/test/tc_basic.rb

@@ -66,6 +66,11 @@ module RGeo
             end
             
             
+            def test_version
+              assert_not_nil(::ActiveRecord::ConnectionAdapters::PostGISAdapter::VERSION)
+            end
+            
+            
             def test_postgis_available
               connection_ = create_ar_class.connection
               assert_equal('PostGIS', connection_.adapter_name)
@@ -73,57 +78,6 @@ module RGeo
             end
             
             
-            def test_create_simple_geometry
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :geometry
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(false, col_.geographic?)
-              assert_equal(4326, col_.srid)
-              assert(klass_.cached_attributes.include?('latlon'))
-              klass_.connection.drop_table(:spatial_test)
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-            
-            
-            def test_create_simple_geography
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :geometry, :geographic => true
-              end
-              col_ = klass_.columns.last
-              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
-              assert_equal(true, col_.geographic?)
-              assert_equal(4326, col_.srid)
-              assert(klass_.cached_attributes.include?('latlon'))
-              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-            end
-            
-            
-            def test_create_point_geometry
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :point
-              end
-              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
-              assert(klass_.cached_attributes.include?('latlon'))
-            end
-            
-            
-            def test_create_geometry_with_index
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column 'latlon', :geometry
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.index([:latlon], :spatial => true)
-              end
-            end
-            
-            
             def test_set_and_get_point
               klass_ = populate_ar_class(:latlon_point)
               obj_ = klass_.new
@@ -182,91 +136,12 @@ module RGeo
             end
             
             
-            def test_add_geometry_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.column('geom2', :point, :srid => 4326)
-                t_.column('name', :string)
-              end
-              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(4326, cols_[-3].srid)
-              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
-              assert_equal(4326, cols_[-2].srid)
-              assert_equal(false, cols_[-2].geographic?)
-              assert_nil(cols_[-1].geometric_type)
-            end
-            
-            
-            def test_add_geography_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.column('geom2', :point, :srid => 4326, :geographic => true)
-                t_.column('name', :string)
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-              assert_equal(4326, cols_[-3].srid)
-              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
-              assert_equal(4326, cols_[-2].srid)
-              assert_equal(true, cols_[-2].geographic?)
-              assert_nil(cols_[-1].geometric_type)
-            end
-            
-            
-            def test_drop_geometry_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-                t_.column('geom2', :point, :srid => 4326)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.remove('geom2')
-              end
-              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Geometry, cols_[-1].geometric_type)
-              assert_equal('latlon', cols_[-1].name)
-              assert_equal(4326, cols_[-1].srid)
-              assert_equal(false, cols_[-1].geographic?)
-            end
-            
-            
-            def test_drop_geography_column
-              klass_ = create_ar_class
-              klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column('latlon', :geometry)
-                t_.column('geom2', :point, :srid => 4326, :geographic => true)
-                t_.column('geom3', :point, :srid => 4326)
-              end
-              klass_.connection.change_table(:spatial_test) do |t_|
-                t_.remove('geom2')
-              end
-              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
-              cols_ = klass_.columns
-              assert_equal(::RGeo::Feature::Point, cols_[-1].geometric_type)
-              assert_equal('geom3', cols_[-1].name)
-              assert_equal(false, cols_[-1].geographic?)
-              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
-              assert_equal('latlon', cols_[-2].name)
-              assert_equal(false, cols_[-2].geographic?)
-            end
-            
-            
             def test_readme_example
               klass_ = create_ar_class
               klass_.connection.create_table(:spatial_test) do |t_|
-                t_.column(:latlon, :point)
-                t_.line_string(:path)
-                t_.geometry(:shape)
+                t_.column(:shape, :geometry)
+                t_.line_string(:path, :srid => 3785)
+                t_.point(:latlon, :geographic => true)
               end
               klass_.connection.change_table(:spatial_test) do |t_|
                 t_.index(:latlon, :spatial => true)
@@ -284,32 +159,6 @@ module RGeo
             end
             
             
-            def test_query_point
-              klass_ = populate_ar_class(:latlon_point)
-              obj_ = klass_.new
-              obj_.latlon = @factory.point(1, 2)
-              obj_.save!
-              id_ = obj_.id
-              obj2_ = klass_.where(:latlon => @factory.multi_point([@factory.point(1, 2)])).first
-              assert_equal(id_, obj2_.id)
-              obj3_ = klass_.where(:latlon => @factory.point(2, 2)).first
-              assert_nil(obj3_)
-            end
-            
-            
-            def test_query_point_wkt
-              klass_ = populate_ar_class(:latlon_point)
-              obj_ = klass_.new
-              obj_.latlon = @factory.point(1, 2)
-              obj_.save!
-              id_ = obj_.id
-              obj2_ = klass_.where(:latlon => 'SRID=4326;POINT(1 2)').first
-              assert_equal(id_, obj2_.id)
-              obj3_ = klass_.where(:latlon => 'SRID=4326;POINT(2 2)').first
-              assert_nil(obj3_)
-            end
-            
-            
           end
           
         end

data/test/tc_ddl.rb

@@ -0,0 +1,270 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for the PostGIS ActiveRecord adapter
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+require 'test/unit'
+require 'rgeo/active_record/adapter_test_helper'
+
+
+module RGeo
+  module ActiveRecord  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      module Tests  # :nodoc:
+        
+        class TestDDL < ::Test::Unit::TestCase  # :nodoc:
+          
+          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
+          include AdapterTestHelper
+          
+          define_test_methods do
+            
+            
+            def test_create_simple_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(false, col_.geographic?)
+              assert_equal(4326, col_.srid)
+              assert(klass_.cached_attributes.include?('latlon'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_simple_geography
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry, :geographic => true
+              end
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(true, col_.geographic?)
+              assert_equal(4326, col_.srid)
+              assert(klass_.cached_attributes.include?('latlon'))
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_point_geometry
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :point
+              end
+              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
+              assert(klass_.cached_attributes.include?('latlon'))
+            end
+            
+            
+            def test_create_geometry_with_index
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'latlon', :geometry
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.index([:latlon], :spatial => true)
+              end
+              assert(klass_.connection.indexes(:spatial_test).last.spatial)
+            end
+            
+            
+            def test_add_geometry_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.column('geom2', :point, :srid => 4326)
+                t_.column('name', :string)
+              end
+              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              cols_ = klass_.columns
+              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
+              assert_equal(4326, cols_[-3].srid)
+              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_equal(false, cols_[-2].geographic?)
+              assert_nil(cols_[-1].geometric_type)
+            end
+            
+            
+            def test_add_geography_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.column('geom2', :point, :srid => 4326, :geographic => true)
+                t_.column('name', :string)
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              cols_ = klass_.columns
+              assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
+              assert_equal(4326, cols_[-3].srid)
+              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_equal(true, cols_[-2].geographic?)
+              assert_nil(cols_[-1].geometric_type)
+            end
+            
+            
+            def test_drop_geometry_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+                t_.column('geom2', :point, :srid => 4326)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.remove('geom2')
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              cols_ = klass_.columns
+              assert_equal(::RGeo::Feature::Geometry, cols_[-1].geometric_type)
+              assert_equal('latlon', cols_[-1].name)
+              assert_equal(4326, cols_[-1].srid)
+              assert_equal(false, cols_[-1].geographic?)
+            end
+            
+            
+            def test_drop_geography_column
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column('latlon', :geometry)
+                t_.column('geom2', :point, :srid => 4326, :geographic => true)
+                t_.column('geom3', :point, :srid => 4326)
+              end
+              klass_.connection.change_table(:spatial_test) do |t_|
+                t_.remove('geom2')
+              end
+              assert_equal(2, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              cols_ = klass_.columns
+              assert_equal(::RGeo::Feature::Point, cols_[-1].geometric_type)
+              assert_equal('geom3', cols_[-1].name)
+              assert_equal(false, cols_[-1].geographic?)
+              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
+              assert_equal('latlon', cols_[-2].name)
+              assert_equal(false, cols_[-2].geographic?)
+            end
+            
+            
+            def test_create_simple_geometry_using_shortcut
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.geometry 'latlon'
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(false, col_.geographic?)
+              assert_equal(4326, col_.srid)
+              assert(klass_.cached_attributes.include?('latlon'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_simple_geography_using_shortcut
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                # t_.method_missing(:geometry, 'latlon', :geographic => true)
+                t_.geometry 'latlon', :geographic => true
+              end
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Geometry, col_.geometric_type)
+              assert_equal(true, col_.geographic?)
+              assert_equal(4326, col_.srid)
+              assert(klass_.cached_attributes.include?('latlon'))
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_point_geometry_using_shortcut
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.point 'latlon'
+              end
+              assert_equal(::RGeo::Feature::Point, klass_.columns.last.geometric_type)
+              assert(klass_.cached_attributes.include?('latlon'))
+            end
+            
+            
+            def test_create_geometry_with_options
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.column 'region', :polygon, :has_m => true, :srid => 3785
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Polygon, col_.geometric_type)
+              assert_equal(false, col_.geographic?)
+              assert_equal(false, col_.has_z?)
+              assert_equal(true, col_.has_m?)
+              assert_equal(3785, col_.srid)
+              assert_equal({:has_m => true, :type => 'polygon', :srid => 3785}, col_.limit)
+              assert(klass_.cached_attributes.include?('region'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+            def test_create_geometry_using_limit
+              klass_ = create_ar_class
+              klass_.connection.create_table(:spatial_test) do |t_|
+                t_.spatial 'region', :limit => {:has_m => true, :srid => 3785, :type => :polygon}
+              end
+              assert_equal(1, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+              col_ = klass_.columns.last
+              assert_equal(::RGeo::Feature::Polygon, col_.geometric_type)
+              assert_equal(false, col_.geographic?)
+              assert_equal(false, col_.has_z)
+              assert_equal(true, col_.has_m)
+              assert_equal(3785, col_.srid)
+              assert_equal({:has_m => true, :type => 'polygon', :srid => 3785}, col_.limit)
+              assert(klass_.cached_attributes.include?('region'))
+              klass_.connection.drop_table(:spatial_test)
+              assert_equal(0, klass_.connection.select_value("SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'").to_i)
+            end
+            
+            
+          end
+          
+        end
+        
+      end
+    end
+  end
+end