activerecord-postgis 0.1.0

data/lib/active_record/connection_adapters/postgis/type/line_string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class LineString < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false, geographic: false)
+            super(geo_type: "line_string", srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          end
+
+          def type
+            :st_line_string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/multi_line_string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class MultiLineString < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false)
+            super(geo_type: "multi_line_string", srid: srid, has_z: has_z, has_m: has_m)
+          end
+
+          def type
+            :st_multi_line_string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/multi_point.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class MultiPoint < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false)
+            super(geo_type: "multi_point", srid: srid, has_z: has_z, has_m: has_m)
+          end
+
+          def type
+            :st_multi_point
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/multi_polygon.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class MultiPolygon < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false, geographic: false)
+            super(geo_type: "multi_polygon", srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          end
+
+          def type
+            :st_multi_polygon
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/point.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class Point < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false, geographic: false)
+            super(geo_type: "point", srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          end
+
+          def type
+            :st_point
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/polygon.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class Polygon < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false)
+            super(geo_type: "polygon", srid: srid, has_z: has_z, has_m: has_m)
+          end
+
+          def type
+            :st_polygon
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/spatial.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "rgeo"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class Spatial < ::ActiveRecord::Type::Value
+          attr_reader :geo_type, :srid, :has_z, :has_m, :geographic
+
+          def initialize(geo_type: "geometry", srid: 0, has_z: false, has_m: false, geographic: false)
+            @geo_type = geographic ? "geography" : geo_type
+            @srid = srid
+            @has_z = has_z
+            @has_m = has_m
+            @geographic = geographic
+            @factory = RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+              geo_type: @geo_type.underscore,
+              srid: srid,
+              has_z: has_z,
+              has_m: has_m,
+              sql_type: (@geographic ? "geography" : "geometry")
+            )
+          end
+
+          def type
+            :geometry
+          end
+
+          def serialize(value)
+            if value.respond_to?(:as_text)
+              "SRID=#{value.srid};#{value.as_text}"
+            elsif value.is_a?(String)
+              value
+            else
+              super
+            end
+          end
+
+          private
+
+          def cast_value(value)
+            case value
+            when ::RGeo::Feature::Instance
+              value
+            when String
+              parse_wkt(value)
+            when Hash
+              parse_hash(value)
+            else
+              nil
+            end
+          end
+
+          def parse_wkt(string)
+            if binary_string?(string)
+              # Parse WKB (Well-Known Binary) format
+              wkb_parser = RGeo::WKRep::WKBParser.new(@factory, support_ewkb: true, default_srid: @srid)
+              wkb_parser.parse(string)
+            else
+              # Parse WKT (Well-Known Text) format
+              wkt_parser = RGeo::WKRep::WKTParser.new(@factory, support_ewkt: true, default_srid: @srid)
+              wkt_parser.parse(string)
+            end
+          rescue RGeo::Error::ParseError
+            nil
+          end
+
+          def binary_string?(string)
+            string[0] == "\x00" || string[0] == "\x01" || string[0, 4] =~ /[0-9a-fA-F]{4}/
+          end
+
+          def parse_hash(hash)
+            # Support GeoJSON-style hash
+            if hash["type"] && hash["coordinates"]
+              RGeo::GeoJSON.decode(hash.to_json, geo_factory: @factory)
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "postgis/version"
+require_relative "postgis/type/geography"
+require_relative "postgis/type/geometry"
+require_relative "postgis/type/geometry_collection"
+require_relative "postgis/type/line_string"
+require_relative "postgis/type/multi_line_string"
+require_relative "postgis/type/multi_point"
+require_relative "postgis/type/multi_polygon"
+require_relative "postgis/type/point"
+require_relative "postgis/type/polygon"
+require_relative "postgis/schema_dumper"
+require_relative "postgis/table_definition"
+require_relative "postgis/column_methods"
+require_relative "postgis/schema_statements"
+require_relative "postgis/spatial_column_type"
+require_relative "postgis/adapter_extensions"
+require_relative "postgis/column_extensions"
+require_relative "postgis/quoting"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      class Error < StandardError; end
+      @initialized = false
+
+      SPATIAL_TYPES_FOR_REGISTRATION = %i[
+        st_geography st_geometry st_geometry_collection st_line_string st_multi_line_string
+        st_multi_point st_multi_polygon st_point st_polygon line_string
+      ].freeze
+
+      SPATIAL_OPTIONS_FOR_REGISTRATION = %i[srid has_z has_m geographic].freeze
+
+      def self.initialize!
+        return if @initialized
+        @initialized = true
+
+        # Extend PostgreSQL Column class with spatial functionality
+        ActiveRecord::ConnectionAdapters::PostgreSQL::Column.include(ColumnExtensions)
+
+        # Add spatial object quoting support
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(Quoting)
+
+        # Allow PostGIS specific options in table definitions
+        # The `define_column_methods` call already makes these available on the `TableDefinition` instance.
+        # The issue might be deeper in how schema.rb is processed or how options are validated.
+        # Let's ensure that the column methods are defined *before* any schema loading that might trigger validation.
+
+        ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include(
+          ActiveRecord::ConnectionAdapters::PostGIS::TableDefinition
+        )
+
+        # Using st_* prefix to avoid conflicts with PostgreSQL native geometric types
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_geography] = { name: "geography" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_geometry] = { name: "geometry" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_geometry_collection] = { name: "geometry(GeometryCollection)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_line_string] = { name: "geometry(LineString)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_multi_line_string] = { name: "geometry(MultiLineString)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_multi_point] = { name: "geometry(MultiPoint)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_multi_polygon] = { name: "geometry(MultiPolygon)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_point] = { name: "geometry(Point)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:st_polygon] = { name: "geometry(Polygon)" }
+
+        # Legacy aliases for compatibility with activerecord-postgis-adapter
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:geography] = { name: "geography" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:geometry] = { name: "geometry" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:geometry_collection] = { name: "geometry(GeometryCollection)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:line_string] = { name: "geometry(LineString)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:multi_line_string] = { name: "geometry(MultiLineString)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:multi_point] = { name: "geometry(MultiPoint)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:multi_polygon] = { name: "geometry(MultiPolygon)" }
+        PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:polygon] = { name: "geometry(Polygon)" }
+
+
+        # Tell Rails these are valid column methods for schema dumping - PostgreSQL only
+        ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.send(:define_column_methods,
+                                                                            :st_geography, :st_geometry, :st_geometry_collection, :st_line_string,
+                                                                            :st_multi_line_string, :st_multi_point, :st_multi_polygon, :st_point, :st_polygon,
+                                                                            # Legacy column methods for compatibility with activerecord-postgis-adapter
+                                                                            :geography, :geometry, :geometry_collection, :line_string,
+                                                                            :multi_line_string, :multi_point, :multi_polygon, :polygon,
+                                                                            *SPATIAL_OPTIONS_FOR_REGISTRATION)
+
+        # prevent unknown OID warning and register PostGIS types
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.singleton_class.prepend(RegisterTypes)
+
+        # Prepend our extensions to handle spatial columns
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(AdapterExtensions)
+
+        # Register spatial types with ActiveRecord::Type - use st_* prefix to avoid conflicts
+        adapter_name = :postgresql
+
+        # Register specific spatial types with their corresponding classes
+        ActiveRecord::Type.register(:st_geography, Type::Geography, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_geometry, Type::Geometry, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_geometry_collection, Type::GeometryCollection, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_line_string, Type::LineString, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_multi_line_string, Type::MultiLineString, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_multi_point, Type::MultiPoint, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_multi_polygon, Type::MultiPolygon, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_point, Type::Point, adapter: adapter_name)
+        ActiveRecord::Type.register(:st_polygon, Type::Polygon, adapter: adapter_name)
+
+        # Legacy type registrations for compatibility with activerecord-postgis-adapter
+        ActiveRecord::Type.register(:geography, Type::Geography, adapter: adapter_name)
+        ActiveRecord::Type.register(:geometry, Type::Geometry, adapter: adapter_name)
+        ActiveRecord::Type.register(:geometry_collection, Type::GeometryCollection, adapter: adapter_name)
+        ActiveRecord::Type.register(:line_string, Type::LineString, adapter: adapter_name)
+        ActiveRecord::Type.register(:multi_line_string, Type::MultiLineString, adapter: adapter_name)
+        ActiveRecord::Type.register(:multi_point, Type::MultiPoint, adapter: adapter_name)
+        ActiveRecord::Type.register(:multi_polygon, Type::MultiPolygon, adapter: adapter_name)
+        ActiveRecord::Type.register(:polygon, Type::Polygon, adapter: adapter_name)
+
+        # Ignore PostGIS system tables in schema dumps - PostgreSQL specific
+        ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.ignore_tables |= %w[
+              geography_columns
+              geometry_columns
+              layer
+              raster_columns
+              raster_overviews
+              spatial_ref_sys
+              topology
+            ]
+      end
+
+      module RegisterTypes
+        def initialize_type_map(m = type_map)
+          super
+
+          # Register by type name for schema loading
+          m.register_type "geography" do |_, _, sql_type|
+            create_spatial_type_from_sql(sql_type)
+          end
+
+          m.register_type "geometry" do |_, _, sql_type|
+            create_spatial_type_from_sql(sql_type)
+          end
+        end
+
+        private
+
+        def create_spatial_type_from_sql(sql_type)
+          # Extract SRID and dimensions from SQL type
+          srid = extract_srid_from_sql(sql_type)
+          # Check for dimension suffixes (e.g., PointZ, PointM, PointZM)
+          has_z = sql_type.match?(/\b\w+Z\b|\b\w+ZM\b/)
+          has_m = sql_type.match?(/\b\w+M\b|\b\w+ZM\b/)
+          geographic = sql_type.start_with?("geography")
+          case sql_type
+          when /geography\(Point/i
+            Type::Point.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(Point/i
+            Type::Point.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geography\(LineString/i
+            Type::LineString.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(LineString/i
+            Type::LineString.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geography\(Polygon/i
+            Type::Polygon.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(Polygon/i
+            Type::Polygon.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geography\(MultiPoint/i
+            Type::MultiPoint.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(MultiPoint/i
+            Type::MultiPoint.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geography\(MultiLineString/i
+            Type::MultiLineString.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(MultiLineString/i
+            Type::MultiLineString.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geography\(MultiPolygon/i
+            Type::MultiPolygon.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(MultiPolygon/i
+            Type::MultiPolygon.new(srid: srid, has_z: has_z, has_m: has_m, geographic: false)
+          when /geography\(GeometryCollection/i
+            Type::GeometryCollection.new(srid: srid, has_z: has_z, has_m: has_m, geographic: geographic)
+          when /geometry\(GeometryCollection/i
+            Type::GeometryCollection.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geography/i
+            Type::Geography.new(srid: srid, has_z: has_z, has_m: has_m)
+          when /geometry/i
+            Type::Geometry.new(srid: srid, has_z: has_z, has_m: has_m)
+          else
+            Type::Geometry.new(srid: srid, has_z: has_z, has_m: has_m)
+          end
+        end
+
+        def extract_srid_from_sql(sql_type)
+          # Extract SRID from patterns like geometry(Point,3785) or geography(Point,4326)
+          match = sql_type.match(/,(\d+)\)/)
+          match ? match[1].to_i : 0
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-postgis.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# dependencies
+require "active_support"
+require "active_record"
+
+# Initialize when PostgreSQL adapter is loaded
+ActiveSupport.on_load(:active_record_postgresqladapter) do
+  require "rgeo-activerecord"
+  require_relative "active_record/connection_adapters/postgis"
+  ActiveRecord::ConnectionAdapters::PostGIS.initialize!
+end

data/lib/arel/visitors/postgis.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "rgeo"
+require "rgeo/active_record/arel_spatial_queries"
+
+module Arel
+  module Nodes
+    # Spatial node classes for different PostGIS functions
+    class SpatialNode < Binary
+      def initialize(left, right = nil)
+        super(left, right)
+      end
+    end
+
+    class SpatialDistance < SpatialNode; end
+    class SpatialLength < Unary; end
+    class SpatialContains < SpatialNode; end
+    class SpatialWithin < SpatialNode; end
+
+    # Wrapper for spatial values that need special handling
+    class SpatialValue < Node
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def st_distance(other)
+        SpatialDistance.new(self, other)
+      end
+
+      def st_contains(other)
+        SpatialContains.new(self, other)
+      end
+
+      def st_within(other)
+        SpatialWithin.new(self, other)
+      end
+    end
+  end
+
+  module Attributes
+    class Attribute
+      def st_distance(other)
+        Arel::Nodes::SpatialDistance.new(self, other)
+      end
+
+      def st_length
+        Arel::Nodes::SpatialLength.new(self)
+      end
+
+      def st_contains(other)
+        Arel::Nodes::SpatialContains.new(self, other)
+      end
+
+      def st_within(other)
+        Arel::Nodes::SpatialWithin.new(self, other)
+      end
+    end
+  end
+
+  # Add Arel.spatial() method
+  def self.spatial(value)
+    Arel::Nodes::SpatialValue.new(value)
+  end
+
+  module Visitors
+    class PostGIS < PostgreSQL
+      include RGeo::ActiveRecord::SpatialToSql
+
+      def visit_in_spatial_context(node, collector)
+        # Use ST_GeomFromEWKT for EWKT geometries
+        if node.is_a?(String) && node =~ /SRID=\d*;/
+          collector << "ST_GeomFromEWKT(#{quote(node)})"
+        else
+          super(node, collector) if defined?(super)
+        end
+      end
+
+      # Visitor methods for spatial nodes
+      def visit_Arel_Nodes_SpatialDistance(node, collector)
+        collector << "ST_Distance("
+        visit(node.left, collector)
+        collector << ", "
+        visit_spatial_operand(node.right, collector)
+        collector << ")"
+      end
+
+      def visit_Arel_Nodes_SpatialLength(node, collector)
+        collector << "ST_Length("
+        visit(node.expr, collector)
+        collector << ")"
+      end
+
+      def visit_Arel_Nodes_SpatialContains(node, collector)
+        collector << "ST_Contains("
+        visit(node.left, collector)
+        collector << ", "
+        visit_spatial_operand(node.right, collector)
+        collector << ")"
+      end
+
+      def visit_Arel_Nodes_SpatialWithin(node, collector)
+        collector << "ST_Within("
+        visit(node.left, collector)
+        collector << ", "
+        visit_spatial_operand(node.right, collector)
+        collector << ")"
+      end
+
+      def visit_Arel_Nodes_SpatialValue(node, collector)
+        visit_spatial_operand(node.value, collector)
+      end
+
+      private
+
+      def visit_spatial_operand(operand, collector)
+        case operand
+        when String
+          if operand =~ /SRID=\d*;/
+            collector << "ST_GeomFromEWKT(#{quote(operand)})"
+          else
+            collector << "ST_GeomFromText(#{quote(operand)})"
+          end
+        when RGeo::Feature::Instance
+          ewkt = if operand.srid && operand.srid != 0
+                   "SRID=#{operand.srid};#{operand.as_text}"
+          else
+                   operand.as_text
+          end
+          collector << "ST_GeomFromEWKT(#{quote(ewkt)})"
+        when RGeo::Cartesian::BoundingBox
+          # Convert bounding box to polygon WKT with SRID if available
+          wkt = "POLYGON((#{operand.min_x} #{operand.min_y}, #{operand.max_x} #{operand.min_y}, #{operand.max_x} #{operand.max_y}, #{operand.min_x} #{operand.max_y}, #{operand.min_x} #{operand.min_y}))"
+          if operand.respond_to?(:srid) && operand.srid && operand.srid != 0
+            ewkt = "SRID=#{operand.srid};#{wkt}"
+            collector << "ST_GeomFromEWKT(#{quote(ewkt)})"
+          else
+            collector << "ST_GeomFromText(#{quote(wkt)})"
+          end
+        else
+          visit(operand, collector)
+        end
+      end
+    end
+  end
+end