activerecord-trilogis-adapter 8.1.1 → 8.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30266da053b3f001b74a6f0fcbcfffe26b11a0205f1e1a2164584f53b995bc21
-  data.tar.gz: ea5ca2afb3df8e11d9697cecb5e1ef5e06209158d1db3178c111c1a3f3aafb9d
+  metadata.gz: cff233bec60dde0ec31a359eb0c3725de326e2bff707a9e8e20e7a59e96d2711
+  data.tar.gz: 32778c148a38f3a15bb6e32f64d6e89f734584fb2c9aea9756e213dea1c6ae68
 SHA512:
-  metadata.gz: 3cd09501502ce9bd8dd42ddbee0e27c88f4285a6c6d9df63cef047e31f1bfa8e6e89aee123c58190b20e089c26a0c5122ff841258d1a6d4b35fec58363bfb523
-  data.tar.gz: ef2a9ed811ce28e493d41a5fcd5bebb8ae7b9a4f34400b80ac80e02cf1f6149d288de532e2133a84a93d21aa757704752f0d5a9cfe125624e399f3d617a38db7
+  metadata.gz: 9382cfbc137be0434e049c40a95d1dce30de00d8008e2f7eff81c18e0d2367bac4531b017f79e53127545abaa3667f298c55df5f40e115f9999dc88442dec0ec
+  data.tar.gz: 8504eaf6bb77294fc427f77556b2bf1291d2a81373c95238e6b8a14974614c329d51d9c4bed49e92fa436d283ce8873b03bc8bbea16b213e2f1c3de9c2c8907b

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

@@ -48,48 +48,36 @@ module Arel
         end
       end
 
-      def visit_spatial_value(node, collector)
-        case node
-        when RGeo::Feature::Instance
-          visit_RGeo_Feature_Instance(node, collector)
-        when String
-          if node.match?(/^[A-Z]/) # WKT string
-            visit_wkt_string(node, collector)
-          else
-            super
-          end
-        else
-          super
-        end
-      end
-
       def visit_RGeo_Feature_Instance(node, collector)
         srid = node.srid || 0
         wkt = node.as_text
 
-        # MySQL ST_GeomFromText supports axis-order option for geographic SRIDs
-        # This ensures longitude-latitude order for SRID 4326 (WGS84)
-        if srid == 4326
-          collector << "ST_GeomFromText('#{wkt}', #{srid}, #{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
+        append_geometry(wkt, srid, collector)
+      end
+
+      def visit_wkt_string(wkt, collector)
+        if (match = /\ASRID=(\d+);(.*)\z/im.match(wkt))
+          append_geometry(match[2], match[1].to_i, collector)
         else
-          collector << "ST_GeomFromText('#{wkt}', #{srid})"
+          append_geometry(wkt, 0, collector)
         end
       end
 
-      def visit_wkt_string(wkt, collector)
-        # Extract SRID if present in EWKT format
-        if wkt =~ /^SRID=(\d+);(.+)$/i
-          srid = Regexp.last_match(1).to_i
-          clean_wkt = Regexp.last_match(2)
-          # Use axis-order for geographic SRID
-          if srid == 4326
-            collector << "ST_GeomFromText('#{clean_wkt}', #{srid}, #{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
+      def append_geometry(wkt, srid, collector)
+        collector << "ST_GeomFromText(#{quote(wkt)}, #{srid}, " \
+                     "#{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
+      end
+
+      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
+        node = node.dup
+        node.expressions = node.expressions.each_with_index.map do |argument, index|
+          if node.spatial_argument?(index) || argument.is_a?(RGeo::ActiveRecord::SpatialConstantNode)
+            argument
           else
-            collector << "ST_GeomFromText('#{clean_wkt}', #{srid})"
+            Arel::Nodes.build_quoted(argument)
           end
-        else
-          collector << "ST_GeomFromText('#{wkt}', 0)"
         end
+        super
       end
 
       # Handle spatial function calls
@@ -140,15 +128,6 @@ module Arel
           collector << quote(value)
         end
       end
-
-      # Support for spatial predicates in WHERE clauses
-      def visit_spatial_predicate(predicate_name, left, right, collector)
-        collector << "#{SPATIAL_FUNCTIONS[predicate_name]}("
-        visit(left, collector)
-        collector << ", "
-        visit(right, collector)
-        collector << ")"
-      end
     end
   end
 end

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

@@ -7,18 +7,7 @@ module ActiveRecord
         private
 
         def add_column_options!(sql, options)
-          # Add SRID option for spatial columns in MySQL 8.0+
-          # Format: /*!80003 SRID #{srid} */
-          if options[:srid]
-            sql_result = "#{sql} /*!80003 SRID #{options[:srid]} */"
-            sql.replace(sql_result)
-
-            # MySQL does not support DEFAULT values for spatial columns
-            # Remove :default option before calling super to prevent SQL errors
-            options = options.dup
-            options.delete(:default)
-          end
-
+          sql << " SRID #{Integer(options[:srid])}" if options[:srid]
           super
         end
       end

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

@@ -5,215 +5,59 @@ module ActiveRecord
     module Trilogis
       module SchemaStatements
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
-          if spatial_type?(type.to_s)
-            # If limit[:type] is specified, use it as the geometry type (e.g., "point")
-            # Otherwise use the base type (e.g., "geometry")
-            base_type = if limit.is_a?(Hash) && limit[:type]
-                          limit[:type]
-                        else
-                          type
-                        end
-            sql_type = spatial_sql_type(base_type, nil)
-            sql_type = "#{sql_type} SRID #{limit[:srid]}" if limit.is_a?(Hash) && limit[:srid]
-            sql_type
-          else
-            super
-          end
+          return super unless (spatial_type = TrilogisAdapter.spatial_type(type))
+
+          spatial_type = TrilogisAdapter.spatial_type(limit[:type]) if limit.is_a?(Hash) && limit[:type]
+          sql = spatial_type.upcase
+          sql += " SRID #{Integer(limit[:srid])}" if limit.is_a?(Hash) && limit[:srid]
+          sql
         end
 
         def add_index(table_name, column_name, **options)
-          index_type = options[:type]
-
-          # Handle spatial indexes - MySQL uses SPATIAL keyword, not USING
-          if index_type == :spatial
-            options = options.dup
-            options.delete(:using) # Remove any USING clause for spatial indexes
-            options[:type] = :spatial
-          end
-
+          options.delete(:using) if options[:type] == :spatial
           super
         end
 
         def indexes(table_name)
-          indexes = super
-
-          # MySQL doesn't support prefix lengths for spatial indexes
-          indexes.each do |index|
-            if index.using == :gist || index.comment&.include?("spatial") || index.type == :spatial
-              index.instance_variable_set(:@lengths, {})
-            end
+          super.each do |index|
+            # MySQL reports a prefix length for SPATIAL keys that cannot be reloaded.
+            index.instance_variable_set(:@lengths, {}) if index.type == :spatial
           end
-
-          indexes
         end
 
-        # Override columns to use parent's implementation but enhance spatial columns
-        # DO NOT override - let parent class handle all column creation
+        def columns(table_name)
+          previous_metadata = @spatial_column_metadata
+          @spatial_column_metadata = nil
+          super
+        ensure
+          @spatial_column_metadata = previous_metadata
+        end
 
-        # Override to properly handle spatial columns creation
         def new_column_from_field(table_name, field, definitions = nil)
-          field_name = extract_field_value(field, :Field, :field)
-          sql_type = extract_field_value(field, :Type, :type)
+          return super unless (spatial_type = TrilogisAdapter.spatial_type(field["Type"]))
 
-          if spatial_type?(sql_type)
-            build_spatial_column(table_name, field, field_name, sql_type)
-          else
-            super
-          end
+          @spatial_column_metadata ||= SpatialColumnInfo.new(self, table_name).all
+          info = @spatial_column_metadata[field["Field"]]
+          cast_type = Type::Spatial.new(info ? "geometry(#{info[:type]},#{info[:srid] || 0})" : spatial_type).freeze
+          SpatialColumn.new(
+            field["Field"], cast_type,
+            nil, fetch_type_metadata(field["Type"]), field["Null"] == "YES", nil,
+            collation: field["Collation"], comment: field["Comment"].presence, spatial_info: info
+          )
         end
 
         def create_table_definition(name, **)
           Trilogis::TableDefinition.new(self, name, **)
         end
 
-        def create_table(table_name, **options, &)
-          # Clear spatial cache when creating table with force: true
-          # This ensures we don't have stale cache from a previously dropped table
-          clear_spatial_cache_for(table_name) if options[:force]
-          super
-        end
-
-        def add_column(table_name, column_name, type, **options)
-          if spatial_type?(type.to_s)
-            # Build ALTER TABLE statement for spatial column
-            sql_type = spatial_sql_type(type, options[:type])
-            base_sql = "ALTER TABLE #{quote_table_name(table_name)} " \
-                       "ADD #{quote_column_name(column_name)} #{sql_type}"
-            sql_parts = [base_sql]
-
-            # Add SRID if specified
-            sql_parts << " SRID #{options[:srid]}" if options[:srid] && options[:srid] != 0
-
-            # Add NULL constraint
-            sql_parts << " NOT NULL" if options[:null] == false
-
-            # MySQL does not support DEFAULT values for spatial/geometry columns
-            # Silently ignore :default option to prevent SQL syntax errors
-            # Users should handle defaults at application level instead
-
-            execute sql_parts.join
-
-            # Clear memoized spatial column info for this table
-            clear_spatial_cache_for(table_name)
-          else
-            super
+        def build_change_column_definition(table_name, column_name, type, **options)
+          column = column_for(table_name, column_name)
+          if column.spatial? && (type.nil? || TrilogisAdapter.spatial_type(type))
+            type ||= column.type
+            options[:srid] = column.srid_constraint unless options.key?(:srid) || options[:limit].is_a?(Hash)
           end
-        end
-
-        def drop_table(table_name, **options)
-          # Clear memoized spatial column info for this table before dropping
-          clear_spatial_cache_for(table_name)
           super
         end
-
-        def rename_table(table_name, new_name)
-          # Clear cache for both old and new table names
-          clear_spatial_cache_for(table_name)
-          clear_spatial_cache_for(new_name)
-          super
-        end
-
-        # Clear all spatial column caches (useful for tests)
-        def clear_spatial_cache!
-          @spatial_column_info = {}
-        end
-
-        def spatial_sql_type(base_type, subtype = nil)
-          sql_type = base_type.to_s.delete("_").upcase
-          subtype_sql = subtype.to_s
-          if subtype_sql.empty?
-            sql_type
-          else
-            "#{sql_type}(#{subtype_sql.delete('_').upcase})"
-          end
-        end
-
-        private
-
-        def spatial_type?(type)
-          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(type.to_s.downcase)
-        end
-
-        def schema_creation
-          SchemaCreation.new(self)
-        end
-
-        # Memoized spatial column info per table
-        def spatial_column_info(table_name)
-          @spatial_column_info ||= {}
-          @spatial_column_info[table_name.to_sym] ||= SpatialColumnInfo.new(self, table_name.to_s)
-        end
-
-        # Clear spatial cache for a specific table
-        def clear_spatial_cache_for(table_name)
-          @spatial_column_info&.delete(table_name.to_sym)
-          @spatial_column_info&.delete(table_name.to_s)
-        end
-
-        # Extract field value with case-insensitive key lookup
-        def extract_field_value(field, *keys)
-          keys.each do |key|
-            return field[key] if field.key?(key)
-            return field[key.to_s] if field.key?(key.to_s)
-          end
-          nil
-        end
-
-        # Build a spatial column from field metadata
-        def build_spatial_column(table_name, field, field_name, sql_type)
-          spatial_info = spatial_column_info(table_name).get(field_name, sql_type)
-
-          # Keep original sql_type in metadata (point, linestring, etc.)
-          # This preserves the actual geometric type for @geo_type_name
-          type_metadata = fetch_type_metadata(sql_type)
-
-          # Lookup cast type as "geometry" for schema dumper compatibility
-          # Schema dumper validates cast_type, and only "geometry" is registered as table method
-          # Actual type is preserved in sql_type_metadata and limit hash
-          cast_type = lookup_cast_type("geometry")
-
-          SpatialColumn.new(
-            field_name,
-            cast_type,
-            nil, # MySQL spatial columns cannot have DEFAULT values
-            type_metadata,
-            extract_field_value(field, :Null, :null) == "YES",
-            nil, # MySQL spatial columns cannot have DEFAULT functions
-            collation: extract_field_value(field, :Collation, :collation),
-            comment: extract_field_value(field, :Comment, :comment).presence,
-            spatial_info: spatial_info
-          )
-        end
-      end
-
-      class SchemaCreation < ActiveRecord::ConnectionAdapters::MySQL::SchemaCreation
-        private
-
-        def visit_ColumnDefinition(o)
-          if spatial_column?(o)
-            sql_type = spatial_sql_type(o.sql_type, o.options[:type])
-            column_sql_parts = ["#{quote_column_name(o.name)} #{sql_type}"]
-
-            # Add SRID if specified (MySQL 8.0+ syntax: COLUMN TYPE SRID value)
-            column_sql_parts << " SRID #{o.options[:srid]}" if o.options[:srid] && o.options[:srid] != 0
-
-            column_sql_parts << " NOT NULL" unless o.null
-
-            # MySQL does not support DEFAULT values for spatial/geometry columns
-            # Silently ignore default to prevent SQL syntax errors
-
-            column_sql_parts.join
-          else
-            super
-          end
-        end
-
-        def spatial_column?(column)
-          # Check both with and without underscores
-          sql_type = column.sql_type.to_s.downcase
-          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type) ||
-            TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type.delete("_"))
-        end
       end
     end
   end

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

@@ -13,7 +13,7 @@ module ActiveRecord
 
     module Trilogis
       class SpatialColumn < ActiveRecord::ConnectionAdapters::MySQL::Column
-        attr_reader :geometric_type, :srid, :geo_type_name
+        attr_reader :geometric_type, :srid, :geo_type_name, :srid_constraint
 
         # Map SQL type strings to RGeo type classes
         GEOMETRIC_TYPES = {
@@ -39,12 +39,13 @@ module ActiveRecord
             # Use spatial info from INFORMATION_SCHEMA if available
             @geo_type_name = spatial_info[:type].to_s.downcase
             @geometric_type = GEOMETRIC_TYPES[@geo_type_name] || RGeo::Feature::Geometry
-            @srid = spatial_info[:srid] || 0
+            @srid_constraint = spatial_info[:srid]
+            @srid = @srid_constraint || 0
             @has_z = spatial_info[:has_z] || false
             @has_m = spatial_info[:has_m] || false
           else
             # Fallback to extracting from SQL type
-            @geo_type_name = sql_type_metadata.sql_type.to_s.downcase
+            @geo_type_name = TrilogisAdapter.spatial_type(sql_type_metadata.sql_type)
             type_info = Type::Spatial.new(@geo_type_name)
             @geometric_type = GEOMETRIC_TYPES[@geo_type_name] || RGeo::Feature::Geometry
             @srid = type_info.srid || 0
@@ -57,7 +58,7 @@ module ActiveRecord
           # Guard against nil sql_type_metadata during type registration
           return false unless sql_type_metadata&.sql_type
 
-          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type_metadata.sql_type.downcase)
+          !TrilogisAdapter.spatial_type(sql_type_metadata.sql_type).nil?
         end
 
         def has_z?
@@ -86,7 +87,31 @@ module ActiveRecord
 
           # Only include SRID in limit
           # Type information is in the type() method
-          { srid: @srid }.compact
+          { srid: @srid_constraint } unless @srid_constraint.nil?
+        end
+
+        def ==(other)
+          super && other.is_a?(self.class) &&
+            srid_constraint == other.srid_constraint && geo_type_name == other.geo_type_name
+        end
+        alias eql? ==
+
+        def hash
+          [super, srid_constraint, geo_type_name].hash
+        end
+
+        def encode_with(coder)
+          super
+          coder["srid_constraint"] = @srid_constraint
+          coder["geo_type_name"] = @geo_type_name
+        end
+
+        def init_with(coder)
+          super
+          @srid_constraint = coder["srid_constraint"]
+          @srid = @srid_constraint || 0
+          @geo_type_name = coder["geo_type_name"]
+          @geometric_type = GEOMETRIC_TYPES.fetch(@geo_type_name, RGeo::Feature::Geometry)
         end
 
         # Override default to always return nil for spatial columns

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

@@ -4,7 +4,6 @@ module ActiveRecord
   module ConnectionAdapters
     module Trilogis
       # Queries MySQL INFORMATION_SCHEMA for spatial column metadata
-      # and caches the results for performance
       class SpatialColumnInfo
         def initialize(adapter, table_name)
           @adapter = adapter
@@ -12,49 +11,37 @@ module ActiveRecord
         end
 
         def all
+          scope = @adapter.send(:quoted_scope, @table_name)
           # Query MySQL's ST_GEOMETRY_COLUMNS view for SRID info
           # This view properly returns SRS_ID for spatial columns
           sql = <<~SQL.squish
             SELECT
               gc.COLUMN_NAME as column_name,
               gc.SRS_ID as srs_id,
-              gc.GEOMETRY_TYPE_NAME as geometry_type,
               c.COLUMN_TYPE as column_type
             FROM INFORMATION_SCHEMA.ST_GEOMETRY_COLUMNS gc
             JOIN INFORMATION_SCHEMA.COLUMNS c
               ON gc.TABLE_SCHEMA = c.TABLE_SCHEMA
               AND gc.TABLE_NAME = c.TABLE_NAME
               AND gc.COLUMN_NAME = c.COLUMN_NAME
-            WHERE gc.TABLE_SCHEMA = DATABASE()
-              AND gc.TABLE_NAME = #{@adapter.quote(@table_name)}
+            WHERE gc.TABLE_SCHEMA = #{scope[:schema]}
+              AND gc.TABLE_NAME = #{scope[:name]}
           SQL
 
           result = {}
           @adapter.exec_query(sql, "SCHEMA").each do |row|
             column_name = row["column_name"] || row["COLUMN_NAME"]
             srs_id = row["srs_id"] || row["SRS_ID"]
-            row["geometry_type"] || row["GEOMETRY_TYPE"]
             column_type = (row["column_type"] || row["COLUMN_TYPE"]).to_s.sub(/m$/, "")
 
             result[column_name] = {
               name: column_name,
-              srid: srs_id.to_i,
-              type: column_type
+              srid: srs_id&.to_i,
+              type: TrilogisAdapter.spatial_type(column_type)
             }
           end
           result
         end
-
-        # Get spatial info for a specific column if it's spatial
-        # Returns nil for non-spatial columns to avoid unnecessary queries
-        def get(column_name, sql_type)
-          # Only query for known spatial types
-          return unless TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type.to_s.downcase)
-
-          # Don't memoize - always query fresh data to avoid stale cache issues
-          # when columns are added during tests
-          all[column_name]
-        end
       end
     end
   end

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

@@ -5,77 +5,17 @@ module RGeo
     module Trilogis
       # MySQL-specific spatial expressions
       module SpatialExpressions
+        # Keep Arel expressions intact; the upstream implementation coerces distance to Float.
+        def st_buffer(distance)
+          SpatialNamedFunction.new("ST_Buffer", [self, distance], [true, true, false])
+        end
+
         # MySQL ST_Distance_Sphere for geographic distance calculations
         def st_distance_sphere(rhs, units = nil)
           args = [self, rhs]
           args << units.to_s if units
           SpatialNamedFunction.new("ST_Distance_Sphere", args, [false, true, true, false])
         end
-
-        # Additional MySQL spatial functions
-        def st_buffer(distance)
-          SpatialNamedFunction.new("ST_Buffer", [self, distance], [false, true, false])
-        end
-
-        def st_contains(rhs)
-          SpatialNamedFunction.new("ST_Contains", [self, rhs], [false, true, true])
-        end
-
-        def st_within(rhs)
-          SpatialNamedFunction.new("ST_Within", [self, rhs], [false, true, true])
-        end
-
-        def st_intersects(rhs)
-          SpatialNamedFunction.new("ST_Intersects", [self, rhs], [false, true, true])
-        end
-
-        def st_crosses(rhs)
-          SpatialNamedFunction.new("ST_Crosses", [self, rhs], [false, true, true])
-        end
-
-        def st_touches(rhs)
-          SpatialNamedFunction.new("ST_Touches", [self, rhs], [false, true, true])
-        end
-
-        def st_overlaps(rhs)
-          SpatialNamedFunction.new("ST_Overlaps", [self, rhs], [false, true, true])
-        end
-
-        def st_equals(rhs)
-          SpatialNamedFunction.new("ST_Equals", [self, rhs], [false, true, true])
-        end
-
-        def st_disjoint(rhs)
-          SpatialNamedFunction.new("ST_Disjoint", [self, rhs], [false, true, true])
-        end
-
-        def st_area
-          SpatialNamedFunction.new("ST_Area", [self], [false, true])
-        end
-
-        def st_length
-          SpatialNamedFunction.new("ST_Length", [self], [false, true])
-        end
-
-        def st_centroid
-          SpatialNamedFunction.new("ST_Centroid", [self], [false, true])
-        end
-
-        def st_envelope
-          SpatialNamedFunction.new("ST_Envelope", [self], [false, true])
-        end
-
-        def st_astext
-          SpatialNamedFunction.new("ST_AsText", [self], [false, true])
-        end
-
-        def st_asbinary
-          SpatialNamedFunction.new("ST_AsBinary", [self], [false, true])
-        end
-
-        def st_srid
-          SpatialNamedFunction.new("ST_SRID", [self], [false, true])
-        end
       end
     end
   end

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

@@ -53,36 +53,30 @@ module ActiveRecord
       class TableDefinition < ActiveRecord::ConnectionAdapters::MySQL::TableDefinition
         include ColumnMethods
 
-        # Override column to handle spatial types
         def column(name, type, index: nil, **options)
-          # Store spatial-specific options before processing
-          spatial_options = {
-            srid: options.delete(:srid),
-            has_m: options.delete(:has_m),
-            has_z: options.delete(:has_z),
-            geographic: options.delete(:geographic)
-          }.compact
-
-          # Call super to create column definition
-          result = super
-
-          # Add spatial options back to the column definition if it's a spatial type
-          if spatial_type?(type) && (col = @columns_hash[name.to_s])
-            spatial_options.each do |key, value|
-              col.options[key] = value
+          index = { type: :spatial } if TrilogisAdapter.spatial_type(type) && [true, :spatial].include?(index)
+          super
+        end
+
+        def new_column_definition(name, type, **options)
+          if (spatial_type = TrilogisAdapter.spatial_type(type))
+            type = spatial_type.to_sym
+            # Retain legacy no-op options for existing migrations.
+            options.except!(:has_z, :has_m, :geographic)
+            options.delete(:default)
+            if options[:limit].is_a?(Hash)
+              limit = options.delete(:limit)
+              type = TrilogisAdapter.spatial_type(limit[:type]).to_sym if limit[:type]
+              options[:srid] = limit[:srid] unless options.key?(:srid)
             end
           end
-
-          # Add spatial index if requested
-          @indexes << [name, { type: :spatial }] if index && spatial_type?(type) && [true, :spatial].include?(index)
-
-          result
+          super
         end
 
         private
 
-        def spatial_type?(type)
-          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(type.to_s)
+        def valid_column_definition_options
+          super + [:srid]
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Trilogis
-      VERSION = "8.1.1"
+      VERSION = "8.1.3"
     end
   end
 end

data/lib/active_record/connection_adapters/trilogis_adapter.rb

@@ -15,48 +15,6 @@ require_relative "../type/spatial"
 require_relative "../tasks/trilogis_database_tasks"
 
 module ActiveRecord
-  module ConnectionHandling
-    # Establishes a connection to the database using the Trilogis adapter.
-    # This adapter extends the built-in Trilogy adapter with spatial support.
-    def trilogis_connection(config)
-      configuration = config.dup
-
-      # Ensure required configuration
-      configuration[:prepared_statements] = true unless configuration.key?(:prepared_statements)
-
-      # Build connection options for Trilogy
-      connection_options = {
-        host: configuration[:host],
-        port: configuration[:port],
-        database: configuration[:database],
-        username: configuration[:username],
-        password: configuration[:password],
-        socket: configuration[:socket],
-        encoding: configuration[:encoding],
-        ssl_mode: configuration[:ssl_mode],
-        connect_timeout: configuration[:connect_timeout],
-        read_timeout: configuration[:read_timeout],
-        write_timeout: configuration[:write_timeout]
-      }.compact
-
-      # Create the Trilogy client connection
-      require "trilogy"
-      client = Trilogy.new(connection_options)
-
-      # Return our spatial-enabled adapter
-      ConnectionAdapters::TrilogisAdapter.new(
-        client,
-        logger,
-        nil,
-        configuration
-      )
-    rescue Trilogy::Error => e
-      raise ActiveRecord::NoDatabaseError if e.message.include?("Unknown database")
-
-      raise
-    end
-  end
-
   module ConnectionAdapters
     class TrilogisAdapter < TrilogyAdapter
       ADAPTER_NAME = "Trilogis"
@@ -75,6 +33,12 @@ module ActiveRecord
         geometrycollection
       ].freeze
 
+      def self.spatial_type(type)
+        name = type.to_s.downcase.delete("_")
+        name = "geometrycollection" if name == "geomcollection"
+        name if SPATIAL_COLUMN_TYPES.include?(name)
+      end
+
       # Default SRID for MySQL
       DEFAULT_SRID = 0
 
@@ -83,63 +47,22 @@ module ActiveRecord
       # in longitude-latitude order instead of MySQL's default latitude-longitude
       AXIS_ORDER_LONG_LAT = "'axis-order=long-lat'"
 
-      # Common geographic SRIDs that use latitude-longitude by default in MySQL 8.0
-      # These need axis-order parameter to work with standard GIS longitude-latitude format
-      GEOGRAPHIC_SRIDS = [
-        4326, # WGS 84 (GPS)
-        4269, # NAD83
-        4267, # NAD27
-        4258, # ETRS89
-        4019  # Unknown datum based upon the GRS 1980 ellipsoid
-      ].freeze
-
-      # Class method to check if a type is spatial
-      def self.spatial_column_options(type)
-        SPATIAL_COLUMN_TYPES.include?(type.to_s.downcase)
-      end
-
-      def initialize(...)
-        super
-
-        # Override the visitor for spatial support
-        @visitor = Arel::Visitors::Trilogis.new(self)
-
-        # Configure RGeo factory generator for SRID-based factory selection
-        configure_rgeo_factory_generator
-      end
-
-      def adapter_name
-        ADAPTER_NAME
+      def self.valid_type?(type)
+        !!spatial_type(type) || super
       end
 
       def supports_spatial?
-        # MySQL 5.7.6+ supports spatial indexes and functions
-        # MariaDB has different spatial support, so we exclude it for now
-        !mariadb? && database_version >= "5.7.6"
+        !mariadb? && database_version >= "8.0"
       end
 
       def default_srid
         DEFAULT_SRID
       end
 
-      def spatial_column_options(_table_name)
-        # Return empty hash as MySQL stores spatial metadata in information_schema
-        {}
-      end
-
-      def with_connection
-        yield self
-      end
-
       def schema_creation
         Trilogis::SchemaCreation.new(self)
       end
 
-      # Override valid_type? to include spatial types
-      def valid_type?(type)
-        SPATIAL_COLUMN_TYPES.include?(type.to_s) || super
-      end
-
       def native_database_types
         super.merge(
           geometry: { name: "geometry" },
@@ -163,26 +86,8 @@ module ActiveRecord
         if value.is_a?(RGeo::Feature::Instance)
           srid = value.srid || DEFAULT_SRID
 
-          # For geographic SRIDs, use axis-order parameter to ensure longitude-latitude order
-          # MySQL 8.0 defaults to latitude-longitude for geographic SRS, but GIS tools use long-lat
-          # ST_GeomFromWKB DOES support axis-order parameter in MySQL 8.0+
           wkb_hex = RGeo::WKRep::WKBGenerator.new(hex_format: true, little_endian: true).generate(value)
-          if geographic_srid?(srid)
-            "ST_GeomFromWKB(0x#{wkb_hex}, #{srid}, #{AXIS_ORDER_LONG_LAT})"
-          else
-            # For projected SRIDs (like 3857), no axis-order needed - uses cartesian X,Y
-            "ST_GeomFromWKB(0x#{wkb_hex}, #{srid})"
-          end
-        else
-          super
-        end
-      end
-
-      def type_cast(value, column = nil)
-        if column&.type == :geometry && value.is_a?(String)
-          # Extract SRID from spatial column if available
-          srid = column.respond_to?(:srid) ? column.srid : DEFAULT_SRID
-          parse_spatial_value(value, srid)
+          "ST_GeomFromWKB(0x#{wkb_hex}, #{srid}, #{AXIS_ORDER_LONG_LAT})"
         else
           super
         end
@@ -190,52 +95,17 @@ module ActiveRecord
 
       private
 
-      def configure_rgeo_factory_generator
-        # Register Geographic factories for geographic SRIDs in RGeo::ActiveRecord::SpatialFactoryStore
-        # This ensures the correct factory (Geographic vs Cartesian) is used based on SRID
-        factory_store = RGeo::ActiveRecord::SpatialFactoryStore.instance
-
-        # Register Geographic spherical factory for each geographic SRID
-        # The registry will match based on SRID and return the appropriate factory
-        GEOGRAPHIC_SRIDS.each do |srid|
-          factory_store.register(
-            RGeo::Geographic.spherical_factory(srid: srid),
-            srid: srid
-          )
-        end
-      end
-
-      def parse_spatial_value(value, srid = DEFAULT_SRID)
-        return nil if value.nil?
-
-        # Ensure SRID is an integer (defensive programming for external callers)
-        srid = srid.to_i
-
-        # Parse WKB hex string using SpatialFactoryStore for correct factory selection
-        if value.is_a?(String) && value.match?(/\A[0-9a-fA-F]+\z/)
-          factory = RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-            geo_type: "geometry",
-            sql_type: "geometry",
-            srid: srid
-          )
-          RGeo::WKRep::WKBParser.new(factory, support_ewkb: true, default_srid: srid).parse([value].pack("H*"))
-        else
-          value
-        end
-      end
-
-      # Check if a SRID is geographic (uses latitude-longitude coordinate system)
-      def geographic_srid?(srid)
-        GEOGRAPHIC_SRIDS.include?(srid)
+      def arel_visitor
+        Arel::Visitors::Trilogis.new(self)
       end
 
       # Override type_map to include spatial types
       def type_map
         @type_map ||= begin
-          map = super.dup
+          map = Type::TypeMap.new(super)
 
           # Add spatial types
-          SPATIAL_COLUMN_TYPES.each do |geo_type|
+          (SPATIAL_COLUMN_TYPES + ["geomcollection"]).each do |geo_type|
             map.register_type(geo_type) do |sql_type|
               Type::Spatial.new(sql_type)
             end
@@ -244,14 +114,6 @@ module ActiveRecord
           map
         end
       end
-
-      def translate_exception(exception, message:, sql:, binds:)
-        if exception.is_a?(::Trilogy::SSLError)
-          return ActiveRecord::ConnectionFailed.new(message, connection_pool: @pool)
-        end
-
-        super
-      end
     end
   end
 end

data/lib/active_record/type/spatial.rb

@@ -6,7 +6,6 @@ module ActiveRecord
       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
 
@@ -87,32 +86,6 @@ module ActiveRecord
 
       private
 
-      def parse_sql_type(sql_type)
-        original_sql_type = sql_type.to_s
-        sql_type = sql_type.to_s.downcase
-
-        # Only parse known spatial types
-        # For non-spatial types, return them unchanged
-        spatial_types = %w[geometry point linestring polygon multipoint multilinestring multipolygon geometrycollection]
-
-        # 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
-
       def parse_string(string)
         return nil if string.blank?
 
@@ -121,12 +94,7 @@ module ActiveRecord
           srid = Regexp.last_match(1).to_i
           wkt = Regexp.last_match(2)
 
-          # Use SpatialFactoryStore to get the appropriate factory
-          geo_factory = RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-            geo_type: @geo_type,
-            sql_type: @sql_type,
-            srid: srid
-          )
+          geo_factory = spatial_factory(srid)
           begin
             return RGeo::WKRep::WKTParser.new(geo_factory, support_ewkt: true, default_srid: srid).parse(wkt)
           rescue RGeo::Error::ParseError
@@ -134,12 +102,11 @@ module ActiveRecord
           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]+$/)
+        # Hex can start with a letter, including MySQL's SRID 4326 prefix (e6100000).
+        if string.match?(/\A[0-9a-fA-F]+\z/)
           parse_wkb_hex(string)
+        elsif string.match?(/^[A-Z]/i)
+          parse_wkt(string)
         end
       end
 
@@ -152,84 +119,27 @@ module ActiveRecord
       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
+        return nil if hex_string.length.odd?
 
-      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
-          parse_standard_wkb(binary)
-        end
-      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)
+        parse_wkb_binary([hex_string].pack("H*"))
       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)
+        # MySQL binary values contain a four-byte SRID prefix followed by WKB.
+        if binary_string.bytesize >= 5
+          srid = binary_string.unpack1("V")
+          begin
+            parser = RGeo::WKRep::WKBParser.new(spatial_factory(srid), support_ewkb: true, default_srid: srid)
+            return parser.parse(binary_string.byteslice(4..))
+          rescue RGeo::Error::ParseError, ArgumentError
+            # Standard WKB has no MySQL prefix; parse the complete input below.
+          end
         end
+
+        RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(binary_string)
       rescue RGeo::Error::ParseError, ArgumentError
-        # Failed to parse, return nil
         nil
       end
 
@@ -240,27 +150,22 @@ module ActiveRecord
         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)
+        unless defined?(RGeo::GeoJSON)
+          raise ArgumentError, 'GeoJSON input requires the rgeo-geojson gem and require "rgeo/geo_json"'
+        end
+
+        RGeo::GeoJSON.decode(normalized_hash, geo_factory: spatial_factory)
       end
 
-      def spatial_factory
-        # Rails 8.1 freezes type objects for Ractor compatibility
-        # If frozen, create factory without caching to avoid FrozenError
-        if frozen?
-          return RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-            geo_type: @geo_type,
-            sql_type: @sql_type,
-            srid: @srid
-          )
+      def spatial_factory(srid = @srid)
+        store = RGeo::ActiveRecord::SpatialFactoryStore.instance
+        attrs = { geo_type: @geo_type, sql_type: @geo_type, srid: srid }
+        registered = store.registry.any? do |entry|
+          entry.attrs.any? && entry.attrs.all? { |key, value| attrs[key] == value }
         end
-
-        # For non-frozen objects, use instance variable caching
-        @spatial_factories ||= {}
-        @spatial_factories[@srid] ||= RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-          geo_type: @geo_type,
-          sql_type: @sql_type,
-          srid: @srid
-        )
+        # Preserve the existing geographic defaults without mutating the global registry.
+        attrs[:sql_type] = "geography" if !registered && [4326, 4269, 4267, 4258, 4019].include?(srid)
+        store.factory(attrs)
       end
     end
   end

data/lib/activerecord-trilogis-adapter.rb

@@ -2,16 +2,9 @@
 
 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,28 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-trilogis-adapter
 version: !ruby/object:Gem::Version
-  version: 8.1.1
+  version: 8.1.3
 platform: ruby
 authors:
 - Ether Moon
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: 8.1.4.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8.1'
+        version: 8.1.4.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
 - !ruby/object:Gem::Dependency
   name: rgeo
   requirement: !ruby/object:Gem::Requirement
@@ -51,6 +58,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: trilogy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.13.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -163,23 +190,9 @@ dependencies:
     - - "~>"
       - !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.1+ native Trilogy adapter. Requires Ruby 3.2+ and Rails 8.1+.
+  8.1 native Trilogy adapter. Requires Ruby 3.3+ and Rails 8.1.4.1+.
 email: chipseru@gmail.com
 executables: []
 extensions: []
@@ -187,7 +200,6 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - lib/active_record/connection_adapters/trilogis/arel_tosql.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
 - lib/active_record/connection_adapters/trilogis/spatial_column.rb
@@ -196,7 +208,6 @@ 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
@@ -205,6 +216,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -212,17 +224,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
   - - "<"
     - !ruby/object:Gem::Version
-      version: '3.5'
+      version: '5.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: ActiveRecord adapter for MySQL with spatial extensions, built on Trilogy.
 test_files: []

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module ConnectionAdapters
-    module Trilogis
-      class Railtie < Rails::Railtie
-        initializer "trilogis.initialize" do
-          ActiveSupport.on_load(:active_record) do
-            require "active_record/connection_adapters/trilogis_adapter"
-          end
-        end
-
-        # Register database tasks for spatial databases
-        rake_tasks do
-          namespace :db do
-            namespace :trilogis do
-              desc "Create spatial extensions if needed"
-              task setup: :environment do
-                ActiveRecord::Base.connection.execute(
-                  "SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() LIMIT 1"
-                )
-                puts "Trilogis adapter is ready. MySQL spatial support enabled."
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/dependency_loader.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-# ActiveRecord dependency loader for all Ruby versions
-#
-# This file explicitly pre-loads all required ActiveRecord modules in the correct
-# dependency order. This approach:
-#
-# - Ensures consistent loading behavior across all Ruby versions (3.2+)
-# - Avoids reliance on Ruby's autoload mechanism, which changed in Ruby 3.4
-# - Prevents "uninitialized constant" errors during module inclusion
-# - Works with ActiveRecord 8.0+ internal structure
-#
-# While this was initially created to solve Ruby 3.4 compatibility issues,
-# using explicit requires for all versions provides better stability and consistency.
-
-# Layer 0: ConnectionAdapters module setup (defines .resolve method)
-require "active_record/connection_adapters"
-
-# Layer 1: Base modules with no dependencies
-require "active_record/connection_adapters/deduplicable"
-
-# Layer 2: Abstract adapter modules
-require "active_record/connection_adapters/abstract/quoting"
-require "active_record/connection_adapters/abstract/database_statements"
-require "active_record/connection_adapters/abstract/schema_statements"
-require "active_record/connection_adapters/abstract/database_limits"
-require "active_record/connection_adapters/abstract/query_cache"
-require "active_record/connection_adapters/abstract/savepoints"
-
-# Layer 3: Column and schema definitions
-require "active_record/connection_adapters/column"
-require "active_record/connection_adapters/abstract/schema_definitions"
-
-# Layer 4: Connection management (needed by ActiveRecord::Base)
-require "active_record/connection_adapters/abstract/connection_handler"
-
-# Layer 5: Abstract MySQL adapter (loads MySQL-specific modules)
-require "active_record/connection_adapters/abstract_mysql_adapter"