activerecord-postgis-adapter 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84cec176fe58c09c168a2e70ded5aa3c6cd340bc
-  data.tar.gz: feb4f2299f2031b0f8f3f5750225600b4f1f8f29
+  metadata.gz: 9072742044be5bdca4d15241b2e55fd59753f07f
+  data.tar.gz: f2f0227789eb674f799d1dee7f85555e1040d4e9
 SHA512:
-  metadata.gz: fd646dad76070fb45abc821d56d5945cf28d76e967f9a479d11bc81d1fe2a4e1cc33c98d7e346eec3a7546f2207d09b3f427f0f3a87a529a12f294cc21701d6b
-  data.tar.gz: 1b916339a0926ced1441a14aecc8f68e21f5bffbf196c64f677f975121622b554bfe178d3819e0eeb2bd78d8d8c878011b819ab97694d74e298d7f3262872748
+  metadata.gz: fde41e0dcd38d4a6d2a7a53f739e50610c998682bb0f5303383e580269ce486ec15fa45aaa698fa5d71e7d943ff404785cb5bf96d785d329877f54d08a0f8732
+  data.tar.gz: f8fe668e18334aefef68f4762e5da778d3b3d4929cab9c1d065a17e55ea392f51954406f643cf47b7021c1372ef3dc42bba397f9d2cc4742bd7718561fb5bc1f

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -16,15 +16,16 @@ require 'active_record'
 require 'active_record/connection_adapters/postgresql_adapter'
 require 'rgeo/active_record'
 
-require 'active_record/connection_adapters/postgis_adapter/version.rb'
-require 'active_record/connection_adapters/postgis_adapter/common_adapter_methods.rb'
-require 'active_record/connection_adapters/postgis_adapter/main_adapter.rb'
-require 'active_record/connection_adapters/postgis_adapter/spatial_table_definition.rb'
-require 'active_record/connection_adapters/postgis_adapter/spatial_column.rb'
-require 'active_record/connection_adapters/postgis_adapter/arel_tosql.rb'
-require 'active_record/connection_adapters/postgis_adapter/setup.rb'
+require 'active_record/connection_adapters/postgis_adapter/version'
+require 'active_record/connection_adapters/postgis_adapter/common_adapter_methods'
+require 'active_record/connection_adapters/postgis_adapter/main_adapter'
+require 'active_record/connection_adapters/postgis_adapter/spatial_column_info'
+require 'active_record/connection_adapters/postgis_adapter/spatial_table_definition'
+require 'active_record/connection_adapters/postgis_adapter/spatial_column'
+require 'active_record/connection_adapters/postgis_adapter/arel_tosql'
+require 'active_record/connection_adapters/postgis_adapter/setup'
 require 'active_record/connection_adapters/postgis_adapter/create_connection'
-require 'active_record/connection_adapters/postgis_adapter/postgis_database_tasks.rb'
+require 'active_record/connection_adapters/postgis_adapter/postgis_database_tasks'
 
 ::ActiveRecord::ConnectionAdapters::PostGISAdapter.initial_setup
 

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

@@ -2,7 +2,7 @@ module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGISAdapter  # :nodoc:
       SPATIAL_COLUMN_CONSTRUCTORS = ::RGeo::ActiveRecord::DEFAULT_SPATIAL_COLUMN_CONSTRUCTORS.merge(
-        :geography => {:type => 'geometry', :geographic => true}
+        geography: { type: 'geometry', geographic: true }
       )
 
       # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
@@ -31,16 +31,16 @@ module ActiveRecord  # :nodoc:
 
         def srs_database_columns
           {
-            :auth_name_column => 'auth_name',
-            :auth_srid_column => 'auth_srid',
-            :proj4text_column => 'proj4text',
-            :srtext_column    => 'srtext',
+            auth_name_column: 'auth_name',
+            auth_srid_column: 'auth_srid',
+            proj4text_column: 'proj4text',
+            srtext_column:    'srtext',
           }
         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)}'"
+            "'#{::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

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

@@ -15,13 +15,14 @@ module ActiveRecord  # :nodoc:
         def native_database_types
           # Overridden to add the :spatial type
           @@native_database_types ||= super.merge(
-            :spatial => {:name => 'geometry'},
-            :geography => {:name => 'geography'})
+            geography: { name: 'geography' },
+            spatial:   { name: 'geometry' },
+          )
         end
 
         def type_cast(value, column, array_member = false)
           if ::RGeo::Feature::Geometry.check_type(value)
-            ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value)
+            ::RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)
           else
             super
           end
@@ -30,8 +31,8 @@ module ActiveRecord  # :nodoc:
         # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS
         # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
         def columns(table_name, name = nil)
+          column_info = SpatialColumnInfo.new(self, quote_string(table_name.to_s))
           # Limit, precision, and scale are all handled by the superclass.
-          spatial_info_ = spatial_column_info(table_name)
           column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
             oid = column_type_map.fetch(oid.to_i, fmod.to_i) { OID::Identity.new }
             SpatialColumn.new(@rgeo_factory_settings,
@@ -41,7 +42,7 @@ module ActiveRecord  # :nodoc:
                               oid,
                               type,
                               notnull == 'f',
-                              type =~ /geometry/i ? spatial_info_[column_name] : nil)
+                              column_info.get(column_name, type))
           end
         end
 
@@ -112,12 +113,15 @@ module ActiveRecord  # :nodoc:
             table_definition = td
           end
           table_definition.non_geographic_spatial_columns.each do |col|
-            type = col.spatial_type.gsub('_', '').upcase
-            has_z = col.has_z?
-            has_m = col.has_m?
-            type = "#{type}M" if has_m && !has_z
-            dimensions_ = set_dimensions(has_m, has_z)
-            execute("SELECT AddGeometryColumn('#{quote_string(table_name)}', '#{quote_string(col.name.to_s)}', #{col.srid}, '#{quote_string(type)}', #{dimensions_})")
+            options = {
+              has_m: col.has_m?,
+              has_z: col.has_z?,
+              srid:  col.srid,
+              type:  col.spatial_type,
+            }
+            column_name = col.name.to_s
+
+            add_spatial_column(table_name, column_name, options)
           end
         end
 
@@ -125,7 +129,7 @@ module ActiveRecord  # :nodoc:
           table_name = table_name.to_s
           column_name = column_name.to_s
           if (info = spatial_column_constructor(type.to_sym))
-            add_spatial_column(column_name, table_name, info, type, options)
+            add_spatial_column(table_name, column_name, info, type, options)
           else
             super
           end
@@ -154,30 +158,12 @@ module ActiveRecord  # :nodoc:
         end
 
         def spatial_column_info(table_name)
-          info = query("SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{quote_string(table_name.to_s)}'")
-          result = {}
-          info.each do |row|
-            name = row[0]
-            type = row[3]
-            dimension = row[1].to_i
-            has_m = !!(type =~ /m$/i)
-            type.sub!(/m$/, '')
-            has_z = dimension > 3 || dimension == 3 && !has_m
-            result[name] = {
-              :name => name,
-              :type => type,
-              :dimension => dimension,
-              :srid => row[2].to_i,
-              :has_z => has_z,
-              :has_m => has_m,
-            }
-          end
-          result
+          SpatialColumnInfo.new(self, quote_string(table_name.to_s)).all
         end
 
         private
 
-        def add_spatial_column(column_name, table_name, info, type, options)
+        def add_spatial_column(table_name, column_name, info = {}, type = nil, options)
           limit = options[:limit]
           options.merge!(limit) if limit.is_a?(::Hash)
           type = (options[:type] || info[:type] || type).to_s.gsub('_', '').upcase
@@ -211,7 +197,6 @@ module ActiveRecord  # :nodoc:
           dimensions += 1 if has_m
           dimensions
         end
-
       end
     end
   end

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

@@ -3,7 +3,7 @@ module ActiveRecord  # :nodoc:
     module PostGISAdapter  # :nodoc:
       class SpatialColumn < ConnectionAdapters::PostgreSQLColumn  # :nodoc:
 
-        def initialize(factory_settings, table_name, name, default, oid_type, sql_type=nil, null=true, opts=nil)
+        def initialize(factory_settings, table_name, name, default, oid_type, sql_type = nil, null = true, opts = nil)
           @factory_settings = factory_settings
           @table_name = table_name
           @geographic = !!(sql_type =~ /geography/i)
@@ -42,12 +42,12 @@ module ActiveRecord  # :nodoc:
           super(name, default, oid_type, sql_type, null)
           if spatial?
             if @srid
-              @limit = {:srid => @srid, :type => @geometric_type.type_name.underscore}
+              @limit = { srid: @srid, type: @geometric_type.type_name.underscore }
               @limit[:has_z] = true if @has_z
               @limit[:has_m] = true if @has_m
               @limit[:geographic] = true if @geographic
             else
-              @limit = {:no_constraints => true}
+              @limit = { no_constraints: true }
             end
           end
         end
@@ -91,8 +91,12 @@ module ActiveRecord  # :nodoc:
 
         def self.convert_to_geometry(input, factory_settings, table_name, column, geographic, srid, has_z, has_m)
           if srid
-            constraints = {:geographic => geographic, :has_z_coordinate => has_z,
-              :has_m_coordinate => has_m, :srid => srid}
+            constraints = {
+              geographic:       geographic,
+              has_z_coordinate: has_z,
+              has_m_coordinate: has_m,
+              srid:             srid
+            }
           else
             constraints = nil
           end
@@ -107,9 +111,9 @@ module ActiveRecord  # :nodoc:
               factory = factory_settings.get_column_factory(table_name, column, constraints)
               marker = input[0,1]
               if marker == "\x00" || marker == "\x01" || input[0,4] =~ /[0-9a-fA-F]{4}/
-                ::RGeo::WKRep::WKBParser.new(factory, :support_ewkb => true).parse(input) rescue nil
+                ::RGeo::WKRep::WKBParser.new(factory, support_ewkb: true).parse(input) rescue nil
               else
-                ::RGeo::WKRep::WKTParser.new(factory, :support_ewkt => true).parse(input) rescue nil
+                ::RGeo::WKRep::WKTParser.new(factory, support_ewkt: true).parse(input) rescue nil
               end
             end
           else
@@ -129,7 +133,7 @@ module ActiveRecord  # :nodoc:
 
         def type_cast(value)
           return if value.nil?
-          ::RGeo::WKRep::WKBParser.new(@factory_generator, :support_ewkb => true).parse(value) rescue nil
+          ::RGeo::WKRep::WKBParser.new(@factory_generator, support_ewkb: true).parse(value) rescue nil
         end
 
       end

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

@@ -0,0 +1,42 @@
+module ActiveRecord  # :nodoc:
+  module ConnectionAdapters  # :nodoc:
+    module PostGISAdapter
+      # Do spatial sql queries for column info and memoize that info.
+      class SpatialColumnInfo
+        def initialize(adapter, table_name)
+          @adapter = adapter
+          @table_name = table_name
+        end
+
+        def all
+          info = @adapter.query("SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{@table_name}'")
+          result = {}
+          info.each do |row|
+            name = row[0]
+            type = row[3]
+            dimension = row[1].to_i
+            has_m = !!(type =~ /m$/i)
+            type.sub!(/m$/, '')
+            has_z = dimension > 3 || dimension == 3 && !has_m
+            result[name] = {
+              dimension: dimension,
+              has_m:     has_m,
+              has_z:     has_z,
+              name:      name,
+              srid:      row[2].to_i,
+              type:      type,
+            }
+          end
+          result
+        end
+
+        # will not query the database for non-spatial columns/tables
+        def get(column_name, type)
+          return nil unless type =~ /geometry/i
+          @spatial_column_info ||= all
+          @spatial_column_info[column_name]
+        end
+      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 = '2.0.2'.freeze
+      VERSION = '2.1.0'.freeze
     end
   end
 end

data/test/basic_test.rb

@@ -1,190 +1,182 @@
 require 'test_helper'
 
-module RGeo
-  module ActiveRecord  # :nodoc:
-    module PostGISAdapter  # :nodoc:
-      module Tests  # :nodoc:
-        class BasicTest < ActiveSupport::TestCase  # :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
+class BasicTest < ActiveSupport::TestCase  # :nodoc:
+  DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
+  OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database_local.yml'
+
+  include RGeo::ActiveRecord::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