activerecord-mysql2rgeo-adapter 7.3.1 → 7.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22e12f955f45c958cdf1d7482072dea06de6c23a55df0863d0e454cb3b2b4814
-  data.tar.gz: 594de2ab90c4ec8cc2ea126ad286eddbf7c44b3ff46a08b204ff92add1baefde
+  metadata.gz: 816dbf40bdc492a42c20ded6aef4f247a76dedbbdd73bc6d705a400f8b8cfdc7
+  data.tar.gz: 4a04ba14c239948df20572c8b29a13f4c6296dfc11edb3beba35b1b76c26124f
 SHA512:
-  metadata.gz: 5f41a95d660e6c21be4a2b3d653e0d47758d74432a36f1ac68075f2a2b079ec4d0da35e30fd83e6e2d7484abd8d9e8a664752aa397d0024690ae01b4afd84047
-  data.tar.gz: 2ff34f00366a8e5861ba4394f1b42d827f1b502e258defe09bd156b28eb9e13f53b7e4b617d8c283fcbe09909885f3002b8a04f8d101723d8c1b7c206975505a
+  metadata.gz: 7dce6e73f2b2f93d1cdd543e6c30e305adf20135faec080f0361a00f1b7f95d34556ac51e4d98fdaa41c565674db4444353529b06b413ac708cf2b0c6750600e
+  data.tar.gz: 2d697dc4767e38740316346fd727dcf352ab1bc41340b4a45ec4c15a3f73f0e1742ba3dc70c0af231aca6f5d091e5d87f9c17b2d6f96493625bc00a3c275ddbd

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

@@ -9,12 +9,10 @@ module Arel # :nodoc:
                         MySQL
                       end
 
-    class Mysql2Rgeo < MySQLSuperclass  # :nodoc:
+    class Mysql2Rgeo < MySQLSuperclass # :nodoc:
       include RGeo::ActiveRecord::SpatialToSql
 
-      if ::Arel::Visitors.const_defined?(:BindVisitor)
-        include ::Arel::Visitors::BindVisitor
-      end
+      include ::Arel::Visitors::BindVisitor if ::Arel::Visitors.const_defined?(:BindVisitor)
 
       FUNC_MAP = {
         "st_wkttosql" => "ST_GeomFromText",
@@ -52,12 +50,12 @@ module Arel # :nodoc:
       end
 
       def self.parse_node(node)
-        if RGeo::Feature::Instance === node
+        if node.is_a?(RGeo::Feature::Instance)
           wkt = RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11, emit_ewkt_srid: false).generate(node)
           return [wkt, node.srid]
         end
 
-        if RGeo::Cartesian::BoundingBox === node
+        if node.is_a?(RGeo::Cartesian::BoundingBox)
           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,34 +5,33 @@ 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
 
-            super
+        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 add_column_options!(sql, options)
-            if options[:srid]
-              sql << " /*!80003 SRID #{options[:srid]} */"
-              options = options.except(:srid)
-            end
+          super
+        end
 
-            if options_include_default?(options) && spatial_column_definition?(options[:column])
-              options = options.except(:default)
-            end
-
-            super
+        def add_column_options!(sql, options)
+          if options[:srid]
+            sql << " /*!80003 SRID #{options[:srid]} */"
+            options = options.except(:srid)
           end
 
-          def spatial_column_definition?(column)
-            column.respond_to?(:type) && column.type && @conn.class.spatial_column_options(column.type.to_sym)
-          end
+          options = options.except(:default) if options_include_default?(options) && spatial_column_definition?(options[:column])
+
+          super
+        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.merge(null: false))
+              change_column(table_name, name, column.limit[:type].to_sym, **column_options, null: false)
             end
           end
 
@@ -42,11 +42,9 @@ module ActiveRecord
 
         # override
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, unsigned: nil, **) # :nodoc:
-          if type.to_sym == :geometry && limit.is_a?(String)
-            return "geometry(#{limit})"
-          end
+          return "geometry(#{limit})" if type.to_sym == :geometry && limit.is_a?(String)
 
-          if (info = RGeo::ActiveRecord.geometric_type_from_name(type.to_s.delete("_")))
+          if 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
@@ -87,7 +85,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
@@ -116,9 +114,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)
@@ -159,10 +157,11 @@ 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(
@@ -185,7 +184,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,7 +4,8 @@ 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
           if spatial
@@ -22,14 +23,13 @@ module ActiveRecord # :nodoc:
             build_from_sql_type(sql_type_metadata.sql_type)
           end
           super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
-          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
+          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?
         end
 
         attr_reader :geometric_type, :srid

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

@@ -5,6 +5,7 @@ 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
@@ -20,7 +21,9 @@ module ActiveRecord # :nodoc:
                          ColumnDefinitionUtils.geo_type(options[:type] || spatial_type || info[:type])
                        end
 
-            unless type.to_sym == :virtual
+            if type.to_sym == :virtual
+              options.delete(:srid)
+            else
               options[:srid] ||= ColumnDefinitionUtils.default_srid(options)
               options[:comment] = ColumnDefinitionUtils.add_metadata_comment(
                 options[:comment],
@@ -32,19 +35,20 @@ module ActiveRecord # :nodoc:
                 srid: options[:srid],
                 geo_type: geo_type
               )
-            else
-              options.delete(:srid)
             end
 
             options[:spatial_type] = geo_type
-            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 = 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
-            options[:comment] = ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array]) if options[:array]
-            column = super(name, type, **options)
+            if options[:array]
+              options[:comment] =
+                ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array])
+            end
+            column = super
           end
 
           column
@@ -77,14 +81,16 @@ 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

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

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

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -29,7 +29,7 @@ module ActiveRecord
       config = config.symbolize_keys
       config[:flags] ||= 0
 
-      if config[:flags].kind_of? Array
+      if config[:flags].is_a? Array
         config[:flags].push "FOUND_ROWS"
       else
         config[:flags] |= Mysql2::Client::FOUND_ROWS
@@ -39,7 +39,7 @@ module ActiveRecord
         ConnectionAdapters::Mysql2RgeoAdapter.new_client(config),
         logger,
         nil,
-        config,
+        config
       )
     end
   end
@@ -110,61 +110,61 @@ 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)
-              end
+
+        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
 
-            [
-              /\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
+          [
+            /\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
 
-            {
-              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
+          {
+            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
 
       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 %r(^tinyint\(1\))i, Type::Boolean.new
+        m.register_type(/^tinyint\(1\)/i, Type::Boolean.new)
       end
 
       def supports_spatial?
@@ -203,16 +203,17 @@ 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 verify_supported_database_version!
+        return if database_version >= MINIMUM_SUPPORTED_VERSION
 
-        def type_map
-          emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
-        end
+        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
     end
   end
 end

data/lib/active_record/type/spatial.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql2rgeo-adapter
 version: !ruby/object:Gem::Version
-  version: 7.3.1
+  version: 7.3.2
 platform: ruby
 authors:
 - Yongdae Hwang
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -137,7 +136,6 @@ metadata:
   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
@@ -152,8 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: ActiveRecord adapter for MySQL, based on RGeo.
 test_files: []