ar-postgis 0.7.0

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

@@ -0,0 +1,184 @@
+module ActiveRecord  # :nodoc:
+
+  module ConnectionAdapters  # :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)
+          @factory_settings = factory_settings_
+          @table_name = table_name_
+          @geographic = sql_type_ =~ /geography/i ? true : false
+          if opts_
+            # This case comes from an entry in the geometry_columns table
+            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts_[:type]) ||
+              ::RGeo::Feature::Geometry
+            @srid = opts_[:srid].to_i
+            @has_z = opts_[:has_z] ? true : false
+            @has_m = opts_[:has_m] ? true : false
+          elsif @geographic
+            # Geographic type information is embedded in the SQL type
+            @geometric_type = ::RGeo::Feature::Geometry
+            @srid = 4326
+            @has_z = @has_m = false
+            if sql_type_ =~ /geography\((.*)\)$/i
+              params_ = $1.split(',')
+              if params_.size >= 2
+                if params_.first =~ /([a-z]+[^zm])(z?)(m?)/i
+                  @has_z = $2.length > 0
+                  @has_m = $3.length > 0
+                  @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name($1)
+                end
+                if params_.last =~ /(\d+)/
+                  @srid = $1.to_i
+                end
+              end
+            end
+          elsif sql_type_ =~ /geography|geometry|point|linestring|polygon/i
+            # Just in case there is a geometry column with no geometry_columns entry.
+            @geometric_type = ::RGeo::Feature::Geometry
+            @srid = @has_z = @has_m = nil
+          else
+            # Non-spatial column
+            @geometric_type = @has_z = @has_m = @srid = nil
+          end
+          super(name_, default_, oid_type_, sql_type_, null_)
+          if spatial?
+            if @srid
+              @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}
+            end
+          end
+        end
+
+
+        attr_reader :geographic
+        attr_reader :srid
+        attr_reader :geometric_type
+        attr_reader :has_z
+        attr_reader :has_m
+
+        alias_method :geographic?, :geographic
+        alias_method :has_z?, :has_z
+        alias_method :has_m?, :has_m
+
+
+        def spatial?
+          type == :spatial || type == :geography
+        end
+
+
+        def has_spatial_constraints?
+          !@srid.nil?
+        end
+
+
+        def klass
+          spatial? ? ::RGeo::Feature::Geometry : super
+        end
+
+
+        def type_cast(value_)
+          if spatial?
+            SpatialColumn.convert_to_geometry(value_, @factory_settings, @table_name, name,
+              @geographic, @srid, @has_z, @has_m)
+          else
+            super
+          end
+        end
+
+
+        private
+
+
+        def simplified_type(sql_type_)
+          sql_type_ =~ /geography|geometry|point|linestring|polygon/i ? :spatial : super
+        end
+
+
+        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_}
+          else
+            constraints_ = nil
+          end
+          if ::RGeo::Feature::Geometry === input_
+            factory_ = factory_settings_.get_column_factory(table_name_, column_, constraints_)
+            ::RGeo::Feature.cast(input_, factory_) rescue nil
+          elsif input_.respond_to?(:to_str)
+            input_ = input_.to_str
+            if input_.length == 0
+              nil
+            else
+              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
+              else
+                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(input_) rescue nil
+              end
+            end
+          else
+            nil
+          end
+        end
+
+
+      end
+
+
+      # Register spatial types with the postgres OID mechanism
+      # so we can recognize custom columns coming from the database.
+
+      class SpatialOID < PostgreSQLAdapter::OID::Type  # :nodoc:
+
+        def initialize(factory_generator_)
+          @factory_generator = factory_generator_
+        end
+
+        def type_cast(value_)
+          return if value_.nil?
+          ::RGeo::WKRep::WKBParser.new(@factory_generator, :support_ewkb => true).parse(value_) rescue nil
+        end
+
+      end
+
+      PostgreSQLAdapter::OID.register_type('geometry', SpatialOID.new(nil))
+      PostgreSQLAdapter::OID.register_type('geography', SpatialOID.new(::RGeo::Geographic.method(:spherical_factory)))
+
+
+      # This is a hack to ActiveRecord::ModelSchema. We have to "decorate" the decorate_columns
+      # method to apply class-specific customizations to spatial type casting.
+
+      module DecorateColumnsModification  # :nodoc:
+
+        def decorate_columns(columns_hash_)
+          columns_hash_ = super(columns_hash_)
+          return unless columns_hash_
+          canonical_columns_ = self.columns_hash
+          columns_hash_.each do |name_, col_|
+            if col_.is_a?(SpatialOID) && (canonical_ = canonical_columns_[name_]) && canonical_.spatial?
+              columns_hash_[name_] = canonical_
+            end
+          end
+          columns_hash_
+        end
+
+      end
+
+      ::ActiveRecord::Base.extend(DecorateColumnsModification)
+
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,121 @@
+module ActiveRecord  # :nodoc:
+
+  module ConnectionAdapters  # :nodoc:
+
+    module PostGISAdapter  # :nodoc:
+
+
+      class TableDefinition < ConnectionAdapters::PostgreSQLAdapter::TableDefinition  # :nodoc:
+
+        def initialize(types_, name_, temporary_, options_, as_, base_)
+          @base = base_
+          @spatial_columns_hash = {}
+          super(types_, name_, temporary_, options_, as_)
+        end
+
+        def column(name_, type_, options_={})
+          if (info_ = @base.spatial_column_constructor(type_.to_sym))
+            type_ = options_[:type] || info_[:type] || type_
+            if type_.to_s == 'geometry' &&
+              (options_[:no_constraints] ||
+               options_[:limit].is_a?(::Hash) && options_[:limit][:no_constraints])
+            then
+              options_.delete(:limit)
+            else
+              options_[:type] = type_
+              type_ = :spatial
+            end
+          end
+          if type_ == :spatial
+            if (limit_ = options_.delete(:limit))
+              options_.merge!(limit_) if limit_.is_a?(::Hash)
+            end
+            if options_[:geographic]
+              type_ = :geography
+              spatial_type_ = (options_[:type] || 'geometry').to_s.upcase.gsub('_', '')
+              spatial_type_ << 'Z' if options_[:has_z]
+              spatial_type_ << 'M' if options_[:has_m]
+              options_[:limit] = "#{spatial_type_},#{options_[:srid] || 4326}"
+            end
+            name_ = name_.to_s
+            if primary_key_column_name == name_
+              raise ArgumentError, "you can't redefine the primary key column '#{name_}'. To define a custom primary key, pass { id: false } to create_table."
+            end
+            col_ = new_column_definition(name_, type_, options_)
+            col_.set_spatial_type(options_[:type])
+            col_.set_geographic(options_[:geographic])
+            col_.set_srid(options_[:srid])
+            col_.set_has_z(options_[:has_z])
+            col_.set_has_m(options_[:has_m])
+            (col_.geographic? ? @columns_hash : @spatial_columns_hash)[name_] = col_
+          else
+            super(name_, type_, options_)
+          end
+          self
+        end
+
+        def create_column_definition(name_, type_)
+          if type_ == :spatial || type_ == :geography
+            PostGISAdapter::ColumnDefinition.new(name_, type_)
+          else
+            super
+          end
+        end
+
+        def non_geographic_spatial_columns
+          @spatial_columns_hash.values
+        end
+
+      end
+
+
+      class ColumnDefinition < ConnectionAdapters::ColumnDefinition  # :nodoc:
+
+        def spatial_type
+          @spatial_type
+        end
+
+        def geographic?
+          @geographic
+        end
+
+        def srid
+          @srid ? @srid.to_i : (geographic? ? 4326 : -1)
+        end
+
+        def has_z?
+          @has_z
+        end
+
+        def 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
+
+      end
+
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,3 @@
+require 'rails/railtie'
+require 'active_record/connection_adapters/postgis_adapter'
+load ::File.expand_path('shared/railtie.rb', ::File.dirname(__FILE__))

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

@@ -0,0 +1,23 @@
+module Arel  # :nodoc:
+  module Visitors  # :nodoc:
+
+    class PostGIS < PostgreSQL  # :nodoc:
+
+      FUNC_MAP = {
+        'st_wkttosql' => 'ST_GeomFromEWKT',
+      }
+
+      include ::RGeo::ActiveRecord::SpatialToSql
+
+      def st_func(standard_name_)
+        FUNC_MAP[standard_name_.downcase] || standard_name_
+      end
+
+      alias_method :visit_in_spatial_context, :visit
+
+    end
+
+    VISITORS['postgis'] = ::Arel::Visitors::PostGIS
+
+  end
+end

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

@@ -0,0 +1,46 @@
+module ActiveRecord  # :nodoc:
+  module ConnectionAdapters  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      SPATIAL_COLUMN_CONSTRUCTORS = ::RGeo::ActiveRecord::DEFAULT_SPATIAL_COLUMN_CONSTRUCTORS.merge(
+        :geography => {:type => 'geometry', :geographic => true}
+      )
+
+      module CommonAdapterMethods  # :nodoc:
+        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_]
+        end
+
+        def postgis_lib_version
+          @postgis_lib_version ||= select_value("SELECT PostGIS_Lib_Version()")
+        end
+
+        # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
+        def default_srid
+          0
+        end
+
+        def srs_database_columns
+          {: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"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+unless defined?(::ActiveRecord::ConnectionAdapters::PostGISAdapter::Railtie)
+  module ActiveRecord  # :nodoc:
+    module ConnectionAdapters  # :nodoc:
+      module PostGISAdapter  # :nodoc:
+        class Railtie < ::Rails::Railtie  # :nodoc:
+          rake_tasks do
+            load ::File.expand_path("../rails4/databases.rake", ::File.dirname(__FILE__))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+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
+      end
+
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGISAdapter
+      VERSION = "0.7.0".freeze
+    end
+  end
+end

data/lib/activerecord-postgis-adapter.rb

@@ -0,0 +1 @@
+require 'active_record/connection_adapters/postgis_adapter.rb'

data/test/database.yml

@@ -0,0 +1,5 @@
+adapter: postgis
+host: 127.0.0.1
+database: postgis_adapter_test
+username: postgres
+setup: default

data/test/tc_basic.rb

@@ -0,0 +1,212 @@
+require 'minitest/autorun'
+require 'rgeo/active_record/adapter_test_helper'
+
+
+module RGeo
+  module ActiveRecord  # :nodoc:
+    module PostGISAdapter  # :nodoc:
+      module Tests  # :nodoc:
+
+        class TestBasic < ::MiniTest::Test  # :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