activerecord-mysql2rgeo-adapter 7.3.2 → 8.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 816dbf40bdc492a42c20ded6aef4f247a76dedbbdd73bc6d705a400f8b8cfdc7
-  data.tar.gz: 4a04ba14c239948df20572c8b29a13f4c6296dfc11edb3beba35b1b76c26124f
+  metadata.gz: b8e687a3f8a5ccfc68ed65b3a4580741bc2b68aa33f18b11a0db6aa3eb5de58d
+  data.tar.gz: f86a9aa0893e135f478701e58bbfd23d99ddf3e5e2ae078dcbb4b5870baa69de
 SHA512:
-  metadata.gz: 7dce6e73f2b2f93d1cdd543e6c30e305adf20135faec080f0361a00f1b7f95d34556ac51e4d98fdaa41c565674db4444353529b06b413ac708cf2b0c6750600e
-  data.tar.gz: 2d697dc4767e38740316346fd727dcf352ab1bc41340b4a45ec4c15a3f73f0e1742ba3dc70c0af231aca6f5d091e5d87f9c17b2d6f96493625bc00a3c275ddbd
+  metadata.gz: 6fc4adc88222d567042ff0017179e86cab2a637ceb601b0406a1835aa7b850d0b7c13861f93d45bc5e83954ec4e956d731cb3d47a586c73048f177dd1b487bb2
+  data.tar.gz: b853618805dc918bb1c10ac1f5cf57ba582deabda7f5ae0dcca4cf8d4657d4c35bf41c22e1e89e3667feceae043d0f7f06ffe3df56781825a6dd723a51a9807d

data/lib/active_record/connection_adapters/mysql2rgeo/arel_tosql.rb

@@ -9,10 +9,12 @@ module Arel # :nodoc:
                         MySQL
                       end
 
-    class Mysql2Rgeo < MySQLSuperclass # :nodoc:
+    class Mysql2Rgeo < MySQLSuperclass  # :nodoc:
       include RGeo::ActiveRecord::SpatialToSql
 
-      include ::Arel::Visitors::BindVisitor if ::Arel::Visitors.const_defined?(:BindVisitor)
+      if ::Arel::Visitors.const_defined?(:BindVisitor)
+        include ::Arel::Visitors::BindVisitor
+      end
 
       FUNC_MAP = {
         "st_wkttosql" => "ST_GeomFromText",
@@ -50,12 +52,12 @@ module Arel # :nodoc:
       end
 
       def self.parse_node(node)
-        if node.is_a?(RGeo::Feature::Instance)
+        if RGeo::Feature::Instance === node
           wkt = RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11, emit_ewkt_srid: false).generate(node)
           return [wkt, node.srid]
         end
 
-        if node.is_a?(RGeo::Cartesian::BoundingBox)
+        if RGeo::Cartesian::BoundingBox === node
           geometry = node.to_geometry
           wkt = RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11, emit_ewkt_srid: false).generate(geometry)
           return [wkt, geometry.srid]

data/lib/active_record/connection_adapters/mysql2rgeo/schema_creation.rb

@@ -5,33 +5,34 @@ module ActiveRecord
     module Mysql2Rgeo
       class SchemaCreation < MySQL::SchemaCreation # :nodoc:
         private
+          def visit_IndexDefinition(o, create = false)
+            if o.using&.to_sym == :gist
+              sql = create ? ["CREATE SPATIAL INDEX"] : ["SPATIAL INDEX"]
+              sql << quote_column_name(o.name)
+              sql << "ON #{quote_table_name(o.table)}" if create
+              sql << "(#{quoted_columns(o)})"
+              return sql.join(" ")
+            end
 
-        def visit_IndexDefinition(o, create = false)
-          if o.using&.to_sym == :gist
-            sql = create ? ["CREATE SPATIAL INDEX"] : ["SPATIAL INDEX"]
-            sql << quote_column_name(o.name)
-            sql << "ON #{quote_table_name(o.table)}" if create
-            sql << "(#{quoted_columns(o)})"
-            return sql.join(" ")
+            super
           end
 
-          super
-        end
+          def add_column_options!(sql, options)
+            if options[:srid]
+              sql << " /*!80003 SRID #{options[:srid]} */"
+              options = options.except(:srid)
+            end
 
-        def add_column_options!(sql, options)
-          if options[:srid]
-            sql << " /*!80003 SRID #{options[:srid]} */"
-            options = options.except(:srid)
-          end
-
-          options = options.except(:default) if options_include_default?(options) && spatial_column_definition?(options[:column])
+            if options_include_default?(options) && spatial_column_definition?(options[:column])
+              options = options.except(:default)
+            end
 
-          super
-        end
+            super
+          end
 
-        def spatial_column_definition?(column)
-          column.respond_to?(:type) && column.type && @conn.class.spatial_column_options(column.type.to_sym)
-        end
+          def spatial_column_definition?(column)
+            column.respond_to?(:type) && column.type && @conn.class.spatial_column_options(column.type.to_sym)
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/mysql2rgeo/schema_statements.rb

@@ -7,7 +7,7 @@ module ActiveRecord
         # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb
 
         # override
-        def indexes(table_name) # :nodoc:
+        def indexes(table_name) #:nodoc:
           indexes = super
           # HACK(aleks, 06/15/18): MySQL 5 does not support prefix lengths for spatial indexes
           # https://dev.mysql.com/doc/refman/5.6/en/create-index.html
@@ -33,7 +33,7 @@ module ActiveRecord
 
               column_options = column.limit.is_a?(Hash) ? column.limit.symbolize_keys.except(:type) : {}
               column_options[:comment] = column.comment if column.comment.present?
-              change_column(table_name, name, column.limit[:type].to_sym, **column_options, null: false)
+              change_column(table_name, name, column.limit[:type].to_sym, **column_options.merge(null: false))
             end
           end
 
@@ -42,15 +42,21 @@ module ActiveRecord
 
         # override
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, unsigned: nil, **) # :nodoc:
-          return "geometry(#{limit})" if type.to_sym == :geometry && limit.is_a?(String)
+          if type.to_sym == :geometry && limit.is_a?(String)
+            return "geometry(#{limit})"
+          end
 
-          if RGeo::ActiveRecord.geometric_type_from_name(type.to_s.delete("_"))
+          if (info = RGeo::ActiveRecord.geometric_type_from_name(type.to_s.delete("_")))
             type = limit[:type] || type if limit.is_a?(::Hash)
             type = type.to_s.delete("_").upcase
           end
           super
         end
 
+        def update_table_definition(table_name, base)
+          Mysql2Rgeo::Table.new(table_name, base)
+        end
+
         private
 
         # override
@@ -63,10 +69,6 @@ module ActiveRecord
           Mysql2Rgeo::TableDefinition.new(self, *args, **options)
         end
 
-        def update_table_definition(table_name, base)
-          Mysql2Rgeo::Table.new(table_name, base)
-        end
-
         # override
         def new_column_from_field(table_name, field, _definitions)
           type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
@@ -85,7 +87,7 @@ module ActiveRecord
             end
 
             if default&.match?(/\Ast_geomfromtext\(/i)
-              default = "(#{default})" unless default.start_with?("(")
+              default = +"(#{default})" unless default.start_with?("(")
               default, default_function = nil, default
             end
           end
@@ -114,9 +116,9 @@ module ActiveRecord
                 type: :geometry,
                 limit: nil,
                 precision: type_metadata.precision,
-                scale: type_metadata.scale
+                scale: type_metadata.scale,
               ),
-              extra: type_metadata.extra
+              extra: type_metadata.extra,
             )
 
             if default_function&.match?(/\A\(?st_geomfromtext\(/i)
@@ -157,11 +159,10 @@ module ActiveRecord
             srid: srid,
             geographic: spatial[:geographic],
             has_z: spatial[:has_z],
-            has_m: spatial[:has_m]
+            has_m: spatial[:has_m],
           )
           geometry = type.serialize(wkt)
           return unless geometry
-
           geometry = RGeo::Feature.cast(geometry, factory: type.send(:spatial_factory), project: true) if spatial[:geographic]
 
           wkb = RGeo::WKRep::WKBGenerator.new(
@@ -170,10 +171,15 @@ module ActiveRecord
             type_format: :wkb11,
             emit_ewkb_srid: false
           ).generate(geometry)
-          return wkb.upcase unless spatial[:geographic]
-
-          srid_hex = [spatial[:srid].to_i].pack("V").unpack1("H*")
-          "#{srid_hex}#{wkb}".upcase
+          wkb = wkb.upcase
+          return wkb unless spatial[:geographic]
+
+          endian = wkb[0, 2]
+          type_hex = wkb[2, 8]
+          body = wkb[10..]
+          type = [type_hex].pack("H*").unpack1("V") | 0x20000000
+          srid_hex = [spatial[:srid].to_i].pack("V").unpack1("H*").upcase
+          "#{endian}#{[type].pack('V').unpack1('H*').upcase}#{srid_hex}#{body}"
         end
 
         def generation_expression_for(table_name, column_name)
@@ -184,7 +190,7 @@ module ActiveRecord
               AND table_name = #{quote(table_name)}
               AND column_name = #{quote(column_name)}
           SQL
-                             &.gsub(/st_buffer\(([^,]+),\s*(\d+)\)/i, 'st_buffer(\1, (\2)::double precision)')
+            &.gsub(/st_buffer\(([^,]+),\s*(\d+)\)/i, 'st_buffer(\1, (\2)::double precision)')
         end
 
         def generated_default_for(table_name, column_name)

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

@@ -4,17 +4,21 @@ module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     module Mysql2Rgeo # :nodoc:
       class SpatialColumn < ConnectionAdapters::MySQL::Column # :nodoc:
-        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil,
-spatial: nil, array: false, **)
+        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, spatial: nil, array: false, **)
           @sql_type_metadata = sql_type_metadata
           @array = array
+          @geographic = !!(sql_type_metadata&.sql_type =~ /geography\(/i)
           if spatial
             # This case comes from an entry in the geometry_columns table
             set_geometric_type_from_name(spatial[:type])
             @srid = spatial[:srid].to_i
-            @has_z = spatial[:has_z]
-            @has_m = spatial[:has_m]
-            @geographic = spatial[:geographic]
+            @has_z = !!spatial[:has_z]
+            @has_m = !!spatial[:has_m]
+            @geographic = !!spatial[:geographic] || @geographic
+          elsif @geographic
+            @srid = 4326
+            @has_z = @has_m = false
+            build_from_sql_type(sql_type_metadata.sql_type)
           elsif sql_type =~ /geometry|point|linestring|polygon/i
             build_from_sql_type(sql_type_metadata.sql_type)
           elsif sql_type_metadata.sql_type =~ /geometry|point|linestring|polygon/i
@@ -23,13 +27,14 @@ spatial: nil, array: false, **)
             build_from_sql_type(sql_type_metadata.sql_type)
           end
           super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
-          return unless spatial?
-          return unless @srid
-
-          @limit = { type: limit_type_name, srid: @srid }
-          @limit[:geographic] = true if geographic?
-          @limit[:has_z] = true if has_z?
-          @limit[:has_m] = true if has_m?
+          if spatial?
+            if @srid
+              @limit = { type: limit_type_name, srid: @srid }
+              @limit[:geographic] = true if geographic?
+              @limit[:has_z] = true if has_z?
+              @limit[:has_m] = true if has_m?
+            end
+          end
         end
 
         attr_reader :geometric_type, :srid
@@ -67,6 +72,30 @@ spatial: nil, array: false, **)
           %i[geometry geography].include?(@sql_type_metadata.type)
         end
 
+        SPATIAL_ATTRIBUTES = %w[geographic geometric_type has_m has_z srid limit].freeze
+
+        def init_with(coder)
+          SPATIAL_ATTRIBUTES.each { |attr| instance_variable_set(:"@#{attr}", coder[attr]) }
+          super
+        end
+
+        def encode_with(coder)
+          SPATIAL_ATTRIBUTES.each { |attr| coder[attr] = instance_variable_get(:"@#{attr}") }
+          super
+        end
+
+        def ==(other)
+          other.is_a?(SpatialColumn) &&
+            super &&
+            array == other.array &&
+            SPATIAL_ATTRIBUTES.all? { |attr| public_send(attr) == other.public_send(attr) }
+        end
+        alias eql? ==
+
+        def hash
+          SPATIAL_ATTRIBUTES.reduce(SpatialColumn.hash ^ super.hash ^ array.hash) { |h, attr| h ^ public_send(attr).hash }
+        end
+
         private
 
         def set_geometric_type_from_name(name)

data/lib/active_record/connection_adapters/mysql2rgeo/spatial_table_definition.rb

@@ -5,7 +5,6 @@ module ActiveRecord # :nodoc:
     module Mysql2Rgeo # :nodoc:
       class TableDefinition < MySQL::TableDefinition # :nodoc:
         include ColumnMethods
-
         # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
         def new_column_definition(name, type, **options)
           spatial_type = type.to_sym == :virtual ? options[:type]&.to_sym : type.to_sym
@@ -21,9 +20,7 @@ module ActiveRecord # :nodoc:
                          ColumnDefinitionUtils.geo_type(options[:type] || spatial_type || info[:type])
                        end
 
-            if type.to_sym == :virtual
-              options.delete(:srid)
-            else
+            unless type.to_sym == :virtual
               options[:srid] ||= ColumnDefinitionUtils.default_srid(options)
               options[:comment] = ColumnDefinitionUtils.add_metadata_comment(
                 options[:comment],
@@ -35,20 +32,19 @@ module ActiveRecord # :nodoc:
                 srid: options[:srid],
                 geo_type: geo_type
               )
+            else
+              options.delete(:srid)
             end
 
             options[:spatial_type] = geo_type
-            column = if type.to_sym == :virtual
-                       super(name, type, **options.merge(type: geo_type.downcase.to_sym))
-                     else
-                       super(name, geo_type.downcase.to_sym, **options)
-                     end
-          else
-            if options[:array]
-              options[:comment] =
-                ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array])
+            if type.to_sym == :virtual
+              column = super(name, type, **options.merge(type: geo_type.downcase.to_sym))
+            else
+              column = super(name, geo_type.downcase.to_sym, **options)
             end
-            column = super
+          else
+            options[:comment] = ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array]) if options[:array]
+            column = super(name, type, **options)
           end
 
           column
@@ -81,16 +77,14 @@ module ActiveRecord # :nodoc:
             options[:geographic] ? 4326 : Mysql2RgeoAdapter::DEFAULT_SRID
           end
 
-          def add_metadata_comment(comment, geographic: false, has_m: false, has_z: false, array: false, default: nil, srid: nil,
-geo_type: nil)
+          def add_metadata_comment(comment, geographic: false, has_m: false, has_z: false, array: false, default: nil, srid: nil, geo_type: nil)
             values = [comment]
             values << METADATA_TOKENS[:geographic] if geographic
             values << METADATA_TOKENS[:has_m] if has_m
             values << METADATA_TOKENS[:has_z] if has_z
             values << METADATA_TOKENS[:array] if array
             if default
-              values << "#{METADATA_TOKENS[:default_prefix]}#{encode_default(default, geographic: geographic, srid: srid,
-                                                                                      geo_type: geo_type, has_m: has_m, has_z: has_z)}"
+              values << "#{METADATA_TOKENS[:default_prefix]}#{encode_default(default, geographic: geographic, srid: srid, geo_type: geo_type, has_m: has_m, has_z: has_z)}"
             end
             values.compact_blank.join(" ")
           end
@@ -134,10 +128,16 @@ geo_type: nil)
               type_format: :wkb11,
               emit_ewkb_srid: false
             ).generate(geometry).upcase
-            return wkb unless geographic
+            geographic ? with_ewkb_srid(wkb, srid) : wkb
+          end
 
+          def with_ewkb_srid(wkb, srid)
+            endian = wkb[0, 2]
+            type_hex = wkb[2, 8]
+            body = wkb[10..]
+            type = [type_hex].pack("H*").unpack1("V") | 0x20000000
             srid_hex = [srid.to_i].pack("V").unpack1("H*").upcase
-            "#{srid_hex}#{wkb}"
+            "#{endian}#{[type].pack('V').unpack1('H*').upcase}#{srid_hex}#{body}"
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Mysql2Rgeo
-      VERSION = "7.3.2"
+      VERSION = "8.0.4"
     end
   end
 end

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -22,6 +22,12 @@ require "active_record/type/spatial"
 
 # :startdoc:
 
+ActiveRecord::ConnectionAdapters.register(
+  "mysql2rgeo",
+  "ActiveRecord::ConnectionAdapters::Mysql2RgeoAdapter",
+  "active_record/connection_adapters/mysql2rgeo_adapter"
+)
+
 module ActiveRecord
   module ConnectionHandling # :nodoc:
     # Establishes a connection to the database that's used by all Active Record objects.
@@ -29,7 +35,7 @@ module ActiveRecord
       config = config.symbolize_keys
       config[:flags] ||= 0
 
-      if config[:flags].is_a? Array
+      if config[:flags].kind_of? Array
         config[:flags].push "FOUND_ROWS"
       else
         config[:flags] |= Mysql2::Client::FOUND_ROWS
@@ -39,7 +45,7 @@ module ActiveRecord
         ConnectionAdapters::Mysql2RgeoAdapter.new_client(config),
         logger,
         nil,
-        config
+        config,
       )
     end
   end
@@ -47,7 +53,6 @@ module ActiveRecord
   module ConnectionAdapters
     class Mysql2RgeoAdapter < Mysql2Adapter
       ADAPTER_NAME = "Mysql2Rgeo"
-      MINIMUM_SUPPORTED_VERSION = "8.0.0"
 
       include Mysql2Rgeo::SchemaStatements
 
@@ -72,12 +77,10 @@ module ActiveRecord
           st_polygon:          { type: "polygon" }
         }.freeze
 
-      # MySQL uses SRID 0 when a spatial column does not declare one explicitly.
       DEFAULT_SRID = 0
 
-      def initialize(connection, logger, connection_options, config)
+      def initialize(...)
         super
-        verify_supported_database_version!
 
         @visitor = Arel::Visitors::Mysql2Rgeo.new(self)
       end
@@ -110,69 +113,74 @@ module ActiveRecord
       end
 
       class << self
-        private
 
-        def initialize_type_map(m)
-          super
-
-          {
-            "geography" => "geometry",
-            "geometry" => "geometry",
-            "geometry_collection" => "geometrycollection",
-            "line_string" => "linestring",
-            "multi_line_string" => "multilinestring",
-            "multi_point" => "multipoint",
-            "multi_polygon" => "multipolygon",
-            "st_point" => "point",
-            "st_polygon" => "polygon",
-          }.each do |registered_type, geo_type|
-            m.register_type(registered_type) do |sql_type|
-              Type::Spatial.new(sql_type.to_s, geo_type: geo_type)
+        private
+          def initialize_type_map(m)
+            super
+
+            {
+              "geography" => "geometry",
+              "geometry" => "geometry",
+              "geometry_collection" => "geometrycollection",
+              "line_string" => "linestring",
+              "multi_line_string" => "multilinestring",
+              "multi_point" => "multipoint",
+              "multi_polygon" => "multipolygon",
+              "st_point" => "point",
+              "st_polygon" => "polygon",
+            }.each do |registered_type, geo_type|
+              m.register_type(registered_type) do |sql_type|
+                Type::Spatial.new(sql_type.to_s, geo_type: geo_type)
+              end
             end
-          end
 
-          [
-            /\Ageometry(?:\(.*\))?\z/i,
-            /\Ageography(?:\(.*\))?\z/i,
-            /\Apoint(?:\s.*)?\z/i,
-            /\Alinestring(?:\s.*)?\z/i,
-            /\Apolygon(?:\s.*)?\z/i,
-            /\Amultipoint(?:\s.*)?\z/i,
-            /\Amultilinestring(?:\s.*)?\z/i,
-            /\Amultipolygon(?:\s.*)?\z/i,
-            /\Ageometrycollection(?:\s.*)?\z/i,
-          ].each do |pattern|
-            m.register_type(pattern) do |sql_type|
-              Type::Spatial.new(sql_type.to_s)
+            [
+              /\Ageometry(?:\(.*\))?\z/i,
+              /\Ageography(?:\(.*\))?\z/i,
+              /\Apoint(?:\s.*)?\z/i,
+              /\Alinestring(?:\s.*)?\z/i,
+              /\Apolygon(?:\s.*)?\z/i,
+              /\Amultipoint(?:\s.*)?\z/i,
+              /\Amultilinestring(?:\s.*)?\z/i,
+              /\Amultipolygon(?:\s.*)?\z/i,
+              /\Ageometrycollection(?:\s.*)?\z/i,
+            ].each do |pattern|
+              m.register_type(pattern) do |sql_type|
+                Type::Spatial.new(sql_type.to_s)
+              end
             end
-          end
 
-          {
-            st_point: "point",
-            st_polygon: "polygon",
-            line_string: "linestring",
-            multi_line_string: "multilinestring",
-            multi_point: "multipoint",
-            multi_polygon: "multipolygon",
-          }.each do |alias_type, geo_type|
-            ActiveRecord::Type.register(alias_type) do |_, **kwargs|
-              Type::Spatial.new(geo_type, geo_type: geo_type, **kwargs)
+            {
+              st_point: "point",
+              st_polygon: "polygon",
+              line_string: "linestring",
+              multi_line_string: "multilinestring",
+              multi_point: "multipoint",
+              multi_polygon: "multipolygon",
+            }.each do |alias_type, geo_type|
+              ActiveRecord::Type.register(alias_type) do |_, **kwargs|
+                Type::Spatial.new(geo_type, geo_type: geo_type, **kwargs)
+              end
             end
+
           end
-        end
       end
 
       TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
       TYPE_MAP_WITH_BOOLEAN = Type::TypeMap.new(TYPE_MAP).tap do |m|
-        m.register_type(/^tinyint\(1\)/i, Type::Boolean.new)
+        m.register_type %r(^tinyint\(1\))i, Type::Boolean.new
       end
 
       def supports_spatial?
-        !mariadb? && database_version >= MINIMUM_SUPPORTED_VERSION
+        !mariadb? && version >= "5.7.6"
+      end
+
+      def supports_partitioned_indexes?
+        false
       end
 
       def adapter_name
-        ADAPTER_NAME
+        "Mysql2Rgeo"
       end
 
       def quote(value)
@@ -203,17 +211,9 @@ module ActiveRecord
       end
 
       private
-
-      def verify_supported_database_version!
-        return if database_version >= MINIMUM_SUPPORTED_VERSION
-
-        raise ActiveRecord::ConnectionNotEstablished,
-              "#{ADAPTER_NAME} supports MySQL #{MINIMUM_SUPPORTED_VERSION}+ only (detected #{database_version})"
-      end
-
-      def type_map
-        emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
-      end
+        def type_map
+          emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
+        end
     end
   end
 end

data/lib/active_record/type/spatial.rb

@@ -41,7 +41,9 @@ module ActiveRecord
             has_z = Regexp.last_match(2).casecmp("z").zero?
             has_m = Regexp.last_match(3).casecmp("m").zero?
           end
-          srid = Regexp.last_match(1).to_i if params.last =~ /(\d+)/
+          if params.last =~ /(\d+)/
+            srid = Regexp.last_match(1).to_i
+          end
         elsif sql_type =~ /\A(geography|geometry)\z/i
           geographic = Regexp.last_match(1).casecmp("geography").zero?
           geo_type = Regexp.last_match(1)
@@ -80,7 +82,7 @@ module ActiveRecord
             has_z: @has_z,
             sql_type: @geographic ? "geography" : "geometry",
             srid: @srid
-          )
+        )
       end
 
       def klass
@@ -116,7 +118,7 @@ module ActiveRecord
       def cast_value(value)
         return if value.nil?
 
-        value.is_a?(::String) ? parse_wkt(value) : value
+        ::String === value ? parse_wkt(value) : value
       end
 
       # convert WKT string into RGeo object
@@ -124,7 +126,7 @@ module ActiveRecord
         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..])
+          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(string[4..-1])
         elsif string.match?(/\A[0-9a-fA-F]+\z/)
           original_srid = @srid
           parser = RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
@@ -139,7 +141,7 @@ module ActiveRecord
             @srid = string[0, 8].to_i(16)
             @srid = [@srid].pack("V").unpack("N").first if string[9, 1] == "1"
             parser = RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
-            return parser.parse([string[8..]].pack("H*"))
+            return parser.parse([string[8..-1]].pack("H*"))
           end
 
           parser.parse([string].pack("H*"))

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql2rgeo-adapter
 version: !ruby/object:Gem::Version
-  version: 7.3.2
+  version: 8.0.4
 platform: ruby
 authors:
 - Yongdae Hwang
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -15,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 7.2.0
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: minitest-excludes
+  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: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -133,9 +148,11 @@ homepage: http://github.com/stadia/activerecord-mysql2rgeo-adapter
 licenses:
 - BSD-3-Clause
 metadata:
+  funding_uri: https://opencollective.com/rgeo
   source_code_uri: https://github.com/stadia/activerecord-mysql2rgeo-adapter
   documentation_uri: https://github.com/stadia/activerecord-mysql2rgeo-adapter/blob/main/README.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -143,14 +160,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 3.3.27
+signing_key:
 specification_version: 4
 summary: ActiveRecord adapter for MySQL, based on RGeo.
 test_files: []