activerecord-trilogis-adapter 7.0.2 → 8.0.1

data/lib/active_record/type/spatial.rb

@@ -2,102 +2,256 @@
 
 module ActiveRecord
   module Type
-    class Spatial < Binary # :nodoc:
-      # sql_type is a string that comes from the database definition
-      # examples:
-      #   "geometry"
-      #   "geometry NOT NULL"
-      #   "geometry"
+    class Spatial < Binary
+      attr_reader :geo_type, :srid
+
       def initialize(sql_type = "geometry")
         @sql_type = sql_type
         @geo_type, @srid = self.class.parse_sql_type(sql_type)
       end
 
-      # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
-      #
-      # returns [geo_type, srid]
-      #   geo_type: geometry, point, line_string, polygon, ...
-      #   srid:     1234
+      def type
+        :geometry
+      end
+
+      # Class method for parsing SQL type
       def self.parse_sql_type(sql_type)
-        geo_type, srid = nil, 0
-        if sql_type =~ /(geometry)\((.*)\)$/i
-          # geometry(Point)
-          # geometry(Point,4326)
-          params = Regexp.last_match(2).split(",")
-          if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
-            geo_type = Regexp.last_match(1)
-          end
-          if params.last =~ /(\d+)/
-            srid = Regexp.last_match(1).to_i
-          end
+        sql_type = sql_type.to_s.downcase
+
+        # Extract geometry type and SRID from SQL type
+        # Examples: "geometry", "point", "linestring", "geometry(Point,4326)"
+        if sql_type =~ /(\w+)(?:\((\w+)(?:,(\d+))?\))?/
+          geo_type = Regexp.last_match(1)
+          sub_type = Regexp.last_match(2)
+          srid = Regexp.last_match(3).to_i
+
+          geo_type = sub_type.downcase if sub_type
+          [geo_type, srid]
         else
-          # geometry
-          # otherType(a,b)
-          geo_type = sql_type
+          [sql_type, 0]
         end
-        [geo_type, srid]
       end
 
-      def spatial_factory
-        @spatial_factories ||= {}
+      def serialize(value)
+        return nil if value.nil?
 
-        @spatial_factories[@srid] ||= RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-          geo_type: @geo_type,
-          sql_type: @sql_type,
-          srid: @srid
-        )
+        # Return the RGeo geometry object as-is
+        # The adapter's quote method will handle conversion to SQL
+        cast(value)
       end
 
-      def klass
-        type == :geometry ? RGeo::Feature::Geometry : super
+      def deserialize(value)
+        return nil if value.nil?
+
+        # Handle RGeo objects directly
+        return value if value.is_a?(RGeo::Feature::Instance)
+
+        # Convert to string if needed and check for empty
+        value = value.to_s if value.respond_to?(:to_s)
+        return nil if value.empty?
+
+        # MySQL returns binary WKB with SRID prefix
+        # Try to parse as binary WKB first
+        if [Encoding::ASCII_8BIT, Encoding::BINARY].include?(value.encoding)
+          result = parse_wkb_binary(value)
+          return result if result
+        end
+
+        # Try hex WKB
+        return parse_wkb_hex(value) if value.match?(/\A[0-9a-fA-F]+\z/)
+
+        # Try WKT
+        parse_wkt(value)
       end
 
-      def spatial?
-        true
+      def cast(value)
+        return nil if value.nil?
+
+        # Check by class name instead of is_a? due to ActiveRecord wrapping values
+        if value.is_a?(RGeo::Feature::Instance)
+          value
+        elsif value.instance_of?(::String) || value.respond_to?(:to_str)
+          parse_string(value.to_s)
+        elsif value.is_a?(Hash)
+          cast_hash(value)
+        end
       end
 
-      def type
-        :geometry
+      def changed?(old_value, new_value, _new_value_before_type_cast)
+        old_value != new_value
       end
 
-      # support setting an RGeo object or a WKT string
-      def serialize(value)
-        return if value.nil?
+      def changed_in_place?(raw_old_value, new_value)
+        deserialize(raw_old_value) != new_value
+      end
+
+      private
 
-        geo_value = cast_value(value)
+      def parse_sql_type(sql_type)
+        original_sql_type = sql_type.to_s
+        sql_type = sql_type.to_s.downcase
 
-        # TODO: - only valid types should be allowed
-        # e.g. linestring is not valid for point column
-        raise "maybe should raise" unless RGeo::Feature::Geometry.check_type(geo_value)
+        # Only parse known spatial types
+        # For non-spatial types, return them unchanged
+        spatial_types = %w[geometry point linestring polygon multipoint multilinestring multipolygon geometrycollection]
 
-        geo_value
+        # Check if it's a spatial type
+        base_type = sql_type.split("(").first
+        return [original_sql_type, 0] unless spatial_types.include?(base_type)
+
+        # Extract geometry type and SRID from SQL type
+        # Examples: "geometry", "point", "linestring", "geometry(Point,4326)"
+        if sql_type =~ /(\w+)(?:\((\w+)(?:,(\d+))?\))?/
+          geo_type = Regexp.last_match(1)
+          sub_type = Regexp.last_match(2)
+          srid = Regexp.last_match(3).to_i
+
+          geo_type = sub_type.downcase if sub_type
+          [geo_type, srid]
+        else
+          [sql_type, 0]
+        end
       end
 
-      private
+      def parse_string(string)
+        return nil if string.blank?
 
-      def cast_value(value)
-        return if value.nil?
+        # Handle EWKT format: SRID=xxxx;GEOMETRY(...)
+        if string =~ /SRID=(\d+);(.+)/i
+          srid = Regexp.last_match(1).to_i
+          wkt = Regexp.last_match(2)
 
-        ::String === value ? parse_wkt(value) : value
+          # Use SpatialFactoryStore to get the appropriate factory
+          geo_factory = RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+            geo_type: @geo_type,
+            sql_type: @sql_type,
+            srid: srid
+          )
+          begin
+            return RGeo::WKRep::WKTParser.new(geo_factory, support_ewkt: true, default_srid: srid).parse(wkt)
+          rescue RGeo::Error::ParseError
+            return nil
+          end
+        end
+
+        # Try to parse as WKT
+        if string.match?(/^[A-Z]/i)
+          parse_wkt(string)
+        # Try to parse as WKB hex
+        elsif string.match?(/^[0-9a-fA-F]+$/)
+          parse_wkb_hex(string)
+        end
       end
 
-      # convert WKT string into RGeo object
       def parse_wkt(string)
-        marker = string[4, 1]
-        if ["\x00", "\x01"].include?(marker)
-          @srid = string[0, 4].unpack1(marker == "\x01" ? "V" : "N")
-          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(string[4..-1])
-        elsif string[0, 10] =~ /[0-9a-fA-F]{8}0[01]/
-          @srid = string[0, 8].to_i(16)
-          @srid = [@srid].pack("V").unpack("N").first if string[9, 1] == "1"
-          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(string[8..-1])
+        # Support EWKT (Extended Well-Known Text) format with SRID
+        RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid).parse(string)
+      rescue RGeo::Error::ParseError
+        # WKT parsing failed, return nil
+        nil
+      end
+
+      def parse_wkb_hex(hex_string)
+        return nil if hex_string.nil? || hex_string.empty?
+
+        binary = convert_hex_to_binary(hex_string)
+        parse_binary_with_srid(binary)
+      rescue RGeo::Error::ParseError, ArgumentError
+        nil
+      end
+
+      def convert_hex_to_binary(hex_string)
+        # MySQL returns WKB as hex string
+        [hex_string].pack("H*")
+      end
+
+      def parse_binary_with_srid(binary)
+        # MySQL internal format: first 4 bytes are SRID (little-endian), then WKB
+        if binary.length >= 5
+          srid = extract_srid(binary)
+          wkb_data = binary[4..]
+          parse_wkb_with_factory(wkb_data, srid)
         else
-          string, @srid = Arel::Visitors::Trilogis.parse_node(string)
-          RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid).parse(string)
+          parse_standard_wkb(binary)
         end
-      rescue RGeo::Error::ParseError, RGeo::Error::InvalidGeometry
+      end
+
+      def extract_srid(binary)
+        # V = unsigned 32-bit little-endian
+        binary[0..3].unpack1("V")
+      end
+
+      def parse_wkb_with_factory(wkb_data, srid)
+        geo_factory = create_factory_for_srid(srid)
+        RGeo::WKRep::WKBParser.new(geo_factory, support_ewkb: true, default_srid: srid).parse(wkb_data)
+      end
+
+      def create_factory_for_srid(srid)
+        # Geographic SRIDs (4326, 4269, 4267, 4258, 4019) need spherical factory
+        if geographic_srid?(srid)
+          RGeo::Geographic.spherical_factory(srid: srid)
+        else
+          RGeo::Cartesian.preferred_factory(srid: srid)
+        end
+      end
+
+      def parse_standard_wkb(binary)
+        # Fall back to standard WKB parsing with EWKB support
+        RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(binary)
+      end
+
+      # Check if SRID represents a geographic coordinate system
+      def geographic_srid?(srid)
+        # Common geographic SRIDs that use latitude-longitude
+        [4326, 4269, 4267, 4258, 4019].include?(srid)
+      end
+
+      def parse_wkb_binary(binary_string)
+        return nil if binary_string.nil? || binary_string.empty?
+
+        # MySQL internal format: first 4 bytes are SRID (little-endian), then WKB
+        if binary_string.length >= 5
+          srid = binary_string[0..3].unpack1("V") # V = unsigned 32-bit little-endian
+          wkb_data = binary_string[4..]
+
+          # Create appropriate factory based on SRID
+          # Geographic SRIDs (4326, 4269, 4267, 4258, 4019) need spherical factory
+          geo_factory = if geographic_srid?(srid)
+                          RGeo::Geographic.spherical_factory(srid: srid)
+                        else
+                          RGeo::Cartesian.preferred_factory(srid: srid)
+                        end
+
+          # Support EWKB format
+          RGeo::WKRep::WKBParser.new(geo_factory, support_ewkb: true, default_srid: srid).parse(wkb_data)
+        else
+          # Fall back to standard WKB parsing with EWKB support
+          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(binary_string)
+        end
+      rescue RGeo::Error::ParseError, ArgumentError
+        # Failed to parse, return nil
         nil
       end
+
+      def cast_hash(hash)
+        return nil unless hash.is_a?(Hash)
+
+        # Support GeoJSON-like hashes (allow symbol or string keys)
+        normalized_hash = hash.transform_keys(&:to_s)
+        return unless normalized_hash["type"] && normalized_hash["coordinates"]
+
+        RGeo::GeoJSON.decode(normalized_hash.to_json, geo_factory: spatial_factory)
+      end
+
+      def spatial_factory
+        @spatial_factories ||= {}
+
+        @spatial_factories[@srid] ||= RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+          geo_type: @geo_type,
+          sql_type: @sql_type,
+          srid: @srid
+        )
+      end
     end
   end
 end

data/lib/activerecord-trilogis-adapter.rb

@@ -1,4 +1,17 @@
 # frozen_string_literal: true
 
-require "active_record/connection_adapters/trilogis_adapter"
-require "active_record/connection_adapters/trilogis/railtie"
+require "active_record"
+
+# Load ActiveRecord dependencies explicitly to ensure correct loading order
+# This approach works across all Ruby versions and avoids autoload issues
+require_relative "active_record/dependency_loader"
+
+require "active_record/connection_adapters/trilogy_adapter"
+require "rgeo"
+require "rgeo/active_record"
+
+# Load the adapter
+require_relative "active_record/connection_adapters/trilogis_adapter"
+
+# Load railtie if Rails is defined
+require_relative "active_record/connection_adapters/trilogis/railtie" if defined?(Rails)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-trilogis-adapter
 version: !ruby/object:Gem::Version
-  version: 7.0.2
+  version: 8.0.1
 platform: ruby
 authors:
 - Ether Moon
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,111 +15,178 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: '8.0'
 - !ruby/object:Gem::Dependency
-  name: rgeo-activerecord
+  name: rgeo
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: activerecord-trilogy-adapter
+  name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '1.81'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '1.81'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: rubocop-minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.38'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.38'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.24'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-description: ActiveRecord connection adapter for MySQL. It is based on the stock MySQL
-  adapter, and adds built-in support for the spatial extensions provided by MySQL.
-  It uses the RGeo library to represent spatial data in Ruby.
+        version: '1.24'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: trilogy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: ActiveRecord connection adapter for MySQL. It extends the Rails built-in
+  Trilogy adapter and adds spatial extensions support via RGeo. Compatible with Rails
+  8.0+ native Trilogy adapter. Requires Ruby 3.2+ and Rails 8.0+.
 email: chipseru@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE.txt
+- LICENSE
 - lib/active_record/connection_adapters/trilogis/arel_tosql.rb
-- lib/active_record/connection_adapters/trilogis/column_methods.rb
-- lib/active_record/connection_adapters/trilogis/connection.rb
-- lib/active_record/connection_adapters/trilogis/rails/dbconsole.rb
 - lib/active_record/connection_adapters/trilogis/railtie.rb
 - lib/active_record/connection_adapters/trilogis/schema_creation.rb
 - lib/active_record/connection_adapters/trilogis/schema_statements.rb
@@ -130,14 +196,15 @@ files:
 - lib/active_record/connection_adapters/trilogis/spatial_table_definition.rb
 - lib/active_record/connection_adapters/trilogis/version.rb
 - lib/active_record/connection_adapters/trilogis_adapter.rb
+- lib/active_record/dependency_loader.rb
 - lib/active_record/tasks/trilogis_database_tasks.rb
 - lib/active_record/type/spatial.rb
 - lib/activerecord-trilogis-adapter.rb
 homepage: http://github.com/ether-moon/activerecord-trilogis-adapter
 licenses:
-- BSD-3-Clause
-metadata: {}
-post_install_message:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -146,14 +213,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: 3.2.0
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '3.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
-summary: ActiveRecord adapter for MySQL, based on RGeo.
+summary: ActiveRecord adapter for MySQL with spatial extensions, built on Trilogy.
 test_files: []

data/LICENSE.txt

@@ -1,29 +0,0 @@
-# -----------------------------------------------------------------------------
-# Copyright 2012 Daniel Azuma
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice,
-#   this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-# * Neither the name of the copyright holder, nor the names of any other
-#   contributors to this software, may be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-# -----------------------------------------------------------------------------

data/lib/active_record/connection_adapters/trilogis/column_methods.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module ConnectionAdapters
-    module Trilogis
-      module ColumnMethods
-        def spatial(name, options = {})
-          raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
-
-          column(name, options[:type], **options)
-        end
-
-        def geometry(name, options = {})
-          column(name, :geometry, **options)
-        end
-
-        def geometry_collection(name, options = {})
-          column(name, :geometrycollection, **options)
-        end
-        alias geometrycollection geometry_collection
-
-        def line_string(name, options = {})
-          column(name, :linestring, **options)
-        end
-        alias linestring line_string
-
-        def multi_line_string(name, options = {})
-          column(name, :multilinestring, **options)
-        end
-        alias multilinestring multi_line_string
-
-        def multi_point(name, options = {})
-          column(name, :multipoint, **options)
-        end
-        alias multipoint multi_point
-
-        def multi_polygon(name, options = {})
-          column(name, :multipolygon, **options)
-        end
-        alias multipolygon multi_polygon
-
-        def point(name, options = {})
-          column(name, :point, **options)
-        end
-
-        def polygon(name, options = {})
-          column(name, :polygon, **options)
-        end
-      end
-    end
-
-    MySQL::Table.include Trilogis::ColumnMethods
-  end
-end