activerecord-postgis-adapter 1.0.0 → 1.1.0

data/lib/active_record/connection_adapters/postgis_adapter/shared/arel_tosql.rb

@@ -9,8 +9,8 @@ module Arel  # :nodoc:
 
       include ::RGeo::ActiveRecord::SpatialToSql
 
-      def st_func(standard_name_)
-        FUNC_MAP[standard_name_.downcase] || standard_name_
+      def st_func(standard_name)
+        FUNC_MAP[standard_name.downcase] || standard_name
       end
 
       alias_method :visit_in_spatial_context, :visit

data/lib/active_record/connection_adapters/postgis_adapter/shared/common_adapter_methods.rb

@@ -9,16 +9,16 @@ module ActiveRecord  # :nodoc:
       DEFAULT_SRID = 0
 
       module CommonAdapterMethods  # :nodoc:
-        def set_rgeo_factory_settings(factory_settings_)
-          @rgeo_factory_settings = factory_settings_
+        def set_rgeo_factory_settings(factory_settings)
+          @rgeo_factory_settings = factory_settings
         end
 
         def adapter_name
           PostGISAdapter::ADAPTER_NAME
         end
 
-        def spatial_column_constructor(name_)
-          PostGISAdapter::SPATIAL_COLUMN_CONSTRUCTORS[name_]
+        def spatial_column_constructor(name)
+          PostGISAdapter::SPATIAL_COLUMN_CONSTRUCTORS[name]
         end
 
         def postgis_lib_version
@@ -33,11 +33,11 @@ module ActiveRecord  # :nodoc:
           {:srtext_column => 'srtext', :proj4text_column => 'proj4text', :auth_name_column => 'auth_name', :auth_srid_column => 'auth_srid'}
         end
 
-        def quote(value_, column_=nil)
-          if ::RGeo::Feature::Geometry.check_type(value_)
-            "'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value_)}'"
-          elsif value_.is_a?(::RGeo::Cartesian::BoundingBox)
-            "'#{value_.min_x},#{value_.min_y},#{value_.max_x},#{value_.max_y}'::box"
+        def quote(value, column=nil)
+          if ::RGeo::Feature::Geometry.check_type(value)
+            "'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value)}'"
+          elsif value.is_a?(::RGeo::Cartesian::BoundingBox)
+            "'#{value.min_x},#{value.min_y},#{value.max_x},#{value.max_y}'::box"
           else
             super
           end

data/lib/active_record/connection_adapters/postgis_adapter/shared/setup.rb

@@ -1,21 +1,11 @@
 module ActiveRecord  # :nodoc:
-
   module ConnectionAdapters  # :nodoc:
-
     module PostGISAdapter  # :nodoc:
 
-
       def self.initial_setup
-        gis_ignore_tables_ = ['geometry_columns', 'spatial_ref_sys', 'layer', 'topology']
-        ignore_tables_ = ::ActiveRecord::SchemaDumper.ignore_tables
-        gis_ignore_tables_.each do |table_|
-          ignore_tables_ << table_ unless ignore_tables_.include?(table_)
-        end
+        ::ActiveRecord::SchemaDumper.ignore_tables |= %w[geometry_columns spatial_ref_sys layer topology]
       end
 
-
     end
-
   end
-
 end

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

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module PostGISAdapter
-      VERSION = "1.0.0".freeze
+      VERSION = '1.1.0'.freeze
     end
   end
 end

data/test/basic_test.rb

@@ -0,0 +1,190 @@
+require 'test_helper'
+
+module RGeo
+  module ActiveRecord  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      module Tests  # :nodoc:
+        class BasicTest < BASE_TEST_CLASS  # :nodoc:
+          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
+          OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database_local.yml'
+
+          include AdapterTestHelper
+
+          define_test_methods do
+
+            def populate_ar_class(content)
+              klass = create_ar_class
+              case content
+              when :mercator_point
+                klass.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'latlon', :point, :srid => 3785
+                end
+              when :latlon_point_geographic
+                klass.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'latlon', :point, :srid => 4326, :geographic => true
+                end
+              when :no_constraints
+                klass.connection.create_table(:spatial_test) do |t_|
+                  t_.column 'geo', :geometry, :no_constraints => true
+                end
+              end
+              klass
+            end
+
+            def test_version
+              refute_nil ::ActiveRecord::ConnectionAdapters::PostGISAdapter::VERSION
+            end
+
+            def test_postgis_available
+              connection = create_ar_class.connection
+              assert_equal 'PostGIS', connection.adapter_name
+              refute_nil connection.postgis_lib_version
+            end
+
+            def test_set_and_get_point
+              klass = populate_ar_class(:mercator_point)
+              obj = klass.new
+              assert_nil obj.latlon
+              obj.latlon = @factory.point(1.0, 2.0)
+              assert_equal @factory.point(1.0, 2.0), obj.latlon
+              assert_equal 3785, obj.latlon.srid
+            end
+
+            def test_set_and_get_point_from_wkt
+              klass = populate_ar_class(:mercator_point)
+              obj = klass.new
+              assert_nil obj.latlon
+              obj.latlon = 'POINT(1 2)'
+              assert_equal @factory.point(1.0, 2.0), obj.latlon
+              assert_equal 3785, obj.latlon.srid
+            end
+
+            def test_save_and_load_point
+              klass = populate_ar_class(:mercator_point)
+              obj = klass.new
+              obj.latlon = @factory.point(1.0, 2.0)
+              obj.save!
+              id = obj.id
+              obj2 = klass.find(id)
+              assert_equal @factory.point(1.0, 2.0), obj2.latlon
+              assert_equal 3785, obj2.latlon.srid
+              assert_equal true, ::RGeo::Geos.is_geos?(obj2.latlon)
+            end
+
+            def test_save_and_load_geographic_point
+              klass = populate_ar_class(:latlon_point_geographic)
+              obj = klass.new
+              obj.latlon = @factory.point(1.0, 2.0)
+              obj.save!
+              id = obj.id
+              obj2 = klass.find(id)
+              assert_equal @geographic_factory.point(1.0, 2.0), obj2.latlon
+              assert_equal 4326, obj2.latlon.srid
+              assert_equal false, ::RGeo::Geos.is_geos?(obj2.latlon)
+            end
+
+            def test_save_and_load_point_from_wkt
+              klass = populate_ar_class(:mercator_point)
+              obj = klass.new
+              obj.latlon = 'POINT(1 2)'
+              obj.save!
+              id = obj.id
+              obj2 = klass.find(id)
+              assert_equal @factory.point(1.0, 2.0), obj2.latlon
+              assert_equal 3785, obj2.latlon.srid
+            end
+
+            def test_set_point_bad_wkt
+              klass = populate_ar_class(:mercator_point)
+              obj = klass.create(:latlon => 'POINT (x)')
+              assert_nil obj.latlon
+            end
+
+            def test_set_point_wkt_wrong_type
+              klass = populate_ar_class(:mercator_point)
+              assert_raises(::ActiveRecord::StatementInvalid) do
+                klass.create(:latlon => 'LINESTRING(1 2, 3 4, 5 6)')
+              end
+            end
+
+            def test_custom_factory
+              klass = create_ar_class
+              klass.connection.create_table(:spatial_test) do |t|
+                t.point(:latlon, :srid => 4326)
+              end
+              factory = ::RGeo::Geographic.simple_mercator_factory
+              klass.class_eval do
+                set_rgeo_factory_for_column(:latlon, factory)
+              end
+              rec_ = klass.new
+              rec_.latlon = 'POINT(-122 47)'
+              assert_equal factory, rec_.latlon.factory
+              rec_.save!
+              assert_equal factory, rec_.latlon.factory
+              rec2_ = klass.find(rec_.id)
+              assert_equal factory, rec2_.latlon.factory
+            end
+
+            def test_readme_example
+              klass = create_ar_class
+              klass.connection.create_table(:spatial_test) do |t_|
+                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)
+              end
+              klass.class_eval do
+                self.rgeo_factory_generator = ::RGeo::Geos.method(:factory)
+                set_rgeo_factory_for_column(:latlon, ::RGeo::Geographic.spherical_factory)
+              end
+              rec_ = klass.new
+              rec_.latlon = 'POINT(-122 47)'
+              loc_ = rec_.latlon
+              assert_equal 47, loc_.latitude
+              rec_.shape = loc_
+              assert_equal true, ::RGeo::Geos.is_geos?(rec_.shape)
+            end
+
+            # no_constraints no longer supported in PostGIS 2.0
+            def _test_save_and_load_no_constraints
+              klass = populate_ar_class(:no_constraints)
+              factory1_ = ::RGeo::Cartesian.preferred_factory(:srid => 3785)
+              factory2_ = ::RGeo::Cartesian.preferred_factory(:srid => 2000)
+              obj = klass.new
+              obj.geo = factory1_.point(1.0, 2.0)
+              obj.save!
+              id = obj.id
+              obj2 = klass.find(id)
+              assert_equal factory1_.point(1.0, 2.0), obj2.geo
+              assert_equal 3785, obj2.geo.srid
+              obj2.geo = factory2_.point(3.0, 4.0)
+              obj2.save!
+              obj3 = klass.find(id)
+              assert_equal factory2_.point(3.0, 4.0), obj3.geo
+              assert_equal 2000, obj3.geo.srid
+            end
+
+            def test_point_to_json
+              klass = populate_ar_class(:mercator_point)
+              obj = klass.new
+              assert_match(/"latlon":null/, obj.to_json)
+              obj.latlon = @factory.point(1.0, 2.0)
+              assert_match(/"latlon":"POINT\s\(1\.0\s2\.0\)"/, obj.to_json)
+            end
+
+            def test_custom_column
+              klass = populate_ar_class(:mercator_point)
+              rec = klass.new
+              rec.latlon = 'POINT(0 0)'
+              rec.save
+              refute_nil klass.select("CURRENT_TIMESTAMP as ts").first.ts
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/test/ddl_test.rb

@@ -0,0 +1,279 @@
+require 'test_helper'
+
+module RGeo
+  module ActiveRecord  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      module Tests  # :nodoc:
+        class DDLTest < BASE_TEST_CLASS  # :nodoc:
+          DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database.yml'
+          OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database_local.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(true, col.has_spatial_constraints?)
+              assert_equal(false, col.geographic?)
+              assert_equal(0, 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
+
+            # no_constraints no longer supported in PostGIS 2.0
+            def _test_create_no_constraints_geometry
+              klass = create_ar_class
+              klass.connection.create_table(:spatial_test) do |t|
+                t.column 'geom', :geometry, :limit => {:no_constraints => true}
+              end
+              assert_equal(0, 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(false, col.has_spatial_constraints?)
+              assert_nil(col.srid)
+              assert(klass.cached_attributes.include?('geom'))
+              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.has_spatial_constraints?)
+              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(0, cols_[-3].srid)
+              assert_equal(true, cols_[-3].has_spatial_constraints?)
+              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_equal(false, cols_[-2].geographic?)
+              assert_equal(true, cols_[-2].has_spatial_constraints?)
+              assert_nil(cols_[-1].geometric_type)
+              assert_equal(false, cols_[-1].has_spatial_constraints?)
+            end
+
+            # no_constraints no longer supported in PostGIS 2.0
+            def _test_add_no_constraints_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', :geometry, :no_constraints => 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(0, cols_[-3].srid)
+              assert_equal(true, cols_[-3].has_spatial_constraints?)
+              assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
+              assert_nil(cols_[-2].srid)
+              assert_equal(false, cols_[-2].geographic?)
+              assert_equal(false, cols_[-2].has_spatial_constraints?)
+              assert_nil(cols_[-1].geometric_type)
+              assert_equal(false, cols_[-1].has_spatial_constraints?)
+            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(0, cols_[-3].srid)
+              assert_equal(true, cols_[-3].has_spatial_constraints?)
+              assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
+              assert_equal(4326, cols_[-2].srid)
+              assert_equal(true, cols_[-2].geographic?)
+              assert_equal(true, cols_[-2].has_spatial_constraints?)
+              assert_nil(cols_[-1].geometric_type)
+              assert_equal(false, cols_[-1].has_spatial_constraints?)
+            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(0, 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(0, 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
+
+            # no_constraints no longer supported in PostGIS 2.0
+            def _test_create_no_constraints_geometry_using_shortcut
+              klass = create_ar_class
+              klass.connection.create_table(:spatial_test) do |t|
+                t.spatial 'geom', :no_constraints => true
+              end
+              assert_equal(0, 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_nil(col.srid)
+              assert(klass.cached_attributes.include?('geom'))
+              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.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