active_record_mysql_spatial 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52dc505e977c105df50ab13b4c4bf1363d778ac41479b0ff578632c4d627a7a4
-  data.tar.gz: de9e452572739eeb2634e8ef919ba4683038b05f3fb9ad47bcd1435c6d036c0d
+  metadata.gz: b423da177a4f62465caf3c5a9c8cf08c017500e152d78b5dbf9daeb6b1f196f1
+  data.tar.gz: ebdd1045ed4b4f49fe3c82f803ba7009af50c0d419be7d77cc94786282095acf
 SHA512:
-  metadata.gz: e3888cef99591d42373885f9f7c06913f0226a2df5eb5f2949f102565f2660a7a76b14896f6148aa881de5b4640ab6bd8d8842247d7e91f34b4cfc63cb81aca4
-  data.tar.gz: 8320501949446a2e6a316b4fac74d1bf026db27e23ec8c65808e5fd3e4766119205fc69c5755a516c04a1111d3f5b15f5e805f2d8b01642a8d0e60daac7e04c6
+  metadata.gz: 3e55747a645a35d839a30c79a2c81b0d749ce9d13a83a767c0e3fbb6a29640a74e701e1acd9416b72dee20592fc36d2737f2091875b5d52eaa155fee2cd5b707
+  data.tar.gz: af598824bcf3cf9ab56189525ee153ba7fa398a022ba5afcbe875b38d9e4bf96be5257472c8bbf9925462cbe63a91c2a1a677139464974683d340ada34919ad3

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper --format documentation

data/lib/active_record_mysql_spatial/active_record/column_methods.rb

@@ -9,8 +9,13 @@ module ActiveRecordMysqlSpatial
 
       included do
         define_column_methods :point,
+                              :polygon,
                               :linestring,
-                              :multilinestring
+                              :multipoint,
+                              :multipolygon,
+                              :geomcollection,
+                              :multilinestring,
+                              :geometrycollection
       end
     end
   end

data/lib/active_record_mysql_spatial/active_record/mysql/base.rb

@@ -5,7 +5,8 @@ module ActiveRecordMysqlSpatial
     module MySQL
       class Base < ::ActiveRecord::Type::Json
         attr_reader :raw,
-                    :error
+                    :error,
+                    :error_backtrace
 
         def type
           raise NotImplementedError
@@ -35,33 +36,52 @@ module ActiveRecordMysqlSpatial
           raise NotImplementedError
         end
 
+        def ==(other)
+          self.class == other.class
+        end
+
         private
 
+        def handle_error(error)
+          @error = error.message
+          @error_backtrace = error.backtrace
+
+          self
+        end
+
         def cast_value(value)
           raise NotImplementedError
         end
 
         def extract_coordinates(attributes, type: :linestring)
-          return [drill_coordinates(attributes) || [], true] if valid_hash?(attributes, type: type)
+          return [attributes, true] if type == :point && attributes.is_a?(Array)
+          return [drill_coordinates(attributes, type: type) || [], true] if valid_hash?(attributes, type: type)
           return [[], false] unless attributes.is_a?(String)
 
           if attributes.encoding.to_s == 'ASCII-8BIT'
-            linestring = Geometry.parse_bin(attributes)
+            spatial_data = Geometry.parse_bin(attributes)
 
-            [linestring.coordinates, false]
+            [drill_elements(spatial_data), false]
           elsif Geometry.valid_spatial?(attributes)
             spatial_data = Geometry.from_text(attributes)
 
-            [spatial_data.coordinates, true]
+            [drill_elements(spatial_data), true]
           else
             parsed_json = ::ActiveSupport::JSON.decode(attributes)
 
-            [parsed_json['coordinates'] || [], true]
+            coordinates = if type == :geometrycollection
+                            parsed_json['geometries']
+                          else
+                            parsed_json['coordinates']
+                          end
+
+            [coordinates || [], true]
           end
         end
 
         def valid_hash?(attributes, type: :linestring)
           return false unless attributes.is_a?(Hash)
+          return attributes.key?(:geometries) || attributes.key?('geometries') if type == :geometrycollection
 
           valid_coord_hash = attributes.key?(:coordinates) || attributes.key?('coordinates') || attributes.key?(:coordinate) || attributes.key?('coordinate')
 
@@ -70,9 +90,19 @@ module ActiveRecordMysqlSpatial
           valid_coord_hash || attributes.key?(:x) || attributes.key?('x') || attributes.key?(:y) || attributes.key?('y')
         end
 
-        def drill_coordinates(attributes)
+        def drill_coordinates(attributes, type: :linestring)
+          return attributes[:geometries].presence || attributes['geometries'] if type == :geometrycollection
+
           attributes[:coordinates].presence || attributes['coordinates'].presence || attributes[:coordinate].presence || attributes['coordinate']
         end
+
+        def drill_elements(spatial)
+          if spatial.geometry_type == RGeo::Feature::GeometryCollection
+            spatial.geometries
+          else
+            spatial.coordinates
+          end
+        end
       end
     end
   end

data/lib/active_record_mysql_spatial/active_record/mysql/geometrycollection.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'active_record_mysql_spatial/geometry'
+
+require_relative 'base'
+require_relative 'linestring'
+require_relative 'multilinestring'
+require_relative 'multipoint'
+require_relative 'multipolygon'
+require_relative 'point'
+require_relative 'polygon'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Geometrycollection < Base
+        attr_accessor :items
+
+        def type
+          :geometrycollection
+        end
+
+        def to_sql
+          return nil if @items.blank?
+
+          "GeometryCollection(#{to_coordinates_sql})"
+        end
+
+        def to_coordinates_sql
+          items.map(&:to_sql).compact.join(', ')
+        end
+
+        def ==(other)
+          return false if super == false
+
+          items.each_with_index do |item, index|
+            return false if item != other.items[index]
+          end
+
+          true
+        end
+
+        private
+
+        def cast_value(value)
+          @raw = value
+          elements, create_raw = extract_coordinates(value, type: :geometrycollection)
+
+          @raw = Geometry.from_geometries(elements).as_binary if create_raw
+
+          @items = elements.map do |geometry|
+            klass, data = extract_data(geometry)
+
+            klass.new.send(:cast_value, data)
+          end
+
+          self
+        rescue StandardError => e
+          handle_error(e)
+        end
+
+        def extract_data(geometry)
+          if geometry.is_a?(Hash)
+            extract_hash_data(geometry)
+          else
+            extract_cartesian_data(geometry)
+          end
+        end
+
+        def extract_cartesian_data(geometry)
+          case geometry.geometry_type
+          when RGeo::Feature::Point
+            [
+              Point,
+              {
+                coordinates: geometry.coordinates
+              }
+            ]
+          when RGeo::Feature::GeometryCollection
+            [
+              Geometrycollection,
+              {
+                geometries: geometry.geometries
+              }
+            ]
+          when RGeo::Feature::LineString
+            [
+              Linestring,
+              {
+                coordinates: geometry.coordinates
+              }
+            ]
+          when RGeo::Feature::MultiLineString
+            [
+              Multilinestring,
+              {
+                coordinates: geometry.coordinates
+              }
+            ]
+          when RGeo::Feature::MultiPoint
+            [
+              Multipoint,
+              {
+                coordinates: geometry.coordinates
+              }
+            ]
+          when RGeo::Feature::MultiPolygon
+            [
+              Multipolygon,
+              {
+                coordinates: geometry.coordinates
+              }
+            ]
+          else
+            [
+              Polygon,
+              {
+                coordinates: geometry.coordinates
+              }
+            ]
+          end
+        end
+
+        def extract_hash_data(geometry)
+          type = geometry[:type].to_s.downcase
+          klass = "ActiveRecordMysqlSpatial::ActiveRecord::MySQL::#{type.camelize}".constantize
+
+          data = if type == 'geometrycollection'
+                   {
+                     geometries: geometry[:geometries] || geometry['geometries']
+                   }
+                 else
+                   {
+                     coordinates: geometry[:coordinates] || geometry['coordinates']
+                   }
+                 end
+
+          [klass, data]
+        end
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/mysql/linestring.rb

@@ -7,25 +7,34 @@ module ActiveRecordMysqlSpatial
   module ActiveRecord
     module MySQL
       class Linestring < Base
-        attr_reader :coordinates
+        attr_reader :items
 
         def type
           :linestring
         end
 
+        def coordinates
+          # TODO: remove later
+          puts 'coordinates is deprecated. Please use items instead.'
+
+          @items
+        end
+
         def to_sql
-          return nil if @coordinates.blank?
+          return nil if @items.blank?
 
           "LineString(#{to_coordinates_sql})"
         end
 
         def to_coordinates_sql
-          @coordinates.map(&:to_coordinate_sql).compact.join(', ')
+          @items.map(&:to_coordinate_sql).compact.join(', ')
         end
 
         def ==(other)
-          coordinates.each_with_index do |coord, index|
-            return false if coord != other.coordinates[index]
+          return false if super == false
+
+          items.each_with_index do |coord, index|
+            return false if coord != other.items[index]
           end
 
           true
@@ -39,15 +48,13 @@ module ActiveRecordMysqlSpatial
 
           @raw = Geometry.from_coordinates(coordinates).as_binary if create_raw
 
-          @coordinates = coordinates.map do |coord|
+          @items = coordinates.map do |coord|
             Point.new.send(:cast_value, coord)
           end
 
           self
         rescue StandardError => e
-          @error = e.message
-
-          self
+          handle_error(e)
         end
       end
     end

data/lib/active_record_mysql_spatial/active_record/mysql/multilinestring.rb

@@ -20,10 +20,12 @@ module ActiveRecordMysqlSpatial
         end
 
         def to_coordinates_sql
-          items.map { |linestring| "(#{linestring.to_coordinates_sql})" }.join(',')
+          items.map { |linestring| "(#{linestring.to_coordinates_sql})" }.join(', ')
         end
 
         def ==(other)
+          return false if super == false
+
           items.each_with_index do |item, index|
             return false if item != other.items[index]
           end
@@ -50,9 +52,7 @@ module ActiveRecordMysqlSpatial
 
           self
         rescue StandardError => e
-          @error = e.message
-
-          self
+          handle_error(e)
         end
       end
     end

data/lib/active_record_mysql_spatial/active_record/mysql/multipoint.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'point'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Multipoint < Base
+        attr_reader :items
+
+        def type
+          :multipoint
+        end
+
+        def to_sql
+          return nil if @items.blank?
+
+          "MultiPoint(#{to_coordinates_sql})"
+        end
+
+        def to_coordinates_sql
+          @items.map(&:to_coordinate_sql).compact.join(', ')
+        end
+
+        def ==(other)
+          return false if super == false
+
+          items.each_with_index do |coord, index|
+            return false if coord != other.items[index]
+          end
+
+          true
+        end
+
+        private
+
+        def cast_value(value)
+          @raw = value
+          coordinates, create_raw = extract_coordinates(value)
+
+          @raw = Geometry.from_coordinates(coordinates, type: :multipoint).as_binary if create_raw
+
+          @items = coordinates.map do |coord|
+            Point.new.send(:cast_value, coord)
+          end
+
+          self
+        rescue StandardError => e
+          handle_error(e)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/mysql/multipolygon.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'polygon'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Multipolygon < Base
+        attr_accessor :items
+
+        def type
+          :multipolygon
+        end
+
+        def to_sql
+          return nil if @items.blank?
+
+          "MultiPolygon(#{to_coordinates_sql})"
+        end
+
+        def to_coordinates_sql
+          items.map { |polygon| "(#{polygon.to_coordinates_sql})" }.join(', ')
+        end
+
+        def ==(other)
+          return false if super == false
+
+          items.each_with_index do |item, index|
+            return false if item != other.items[index]
+          end
+
+          true
+        end
+
+        private
+
+        def cast_value(value)
+          @raw = value
+          coordinates, create_raw = extract_coordinates(value)
+
+          @raw = Geometry.from_coordinates(coordinates, type: :multipolygon).as_binary if create_raw
+
+          @items = coordinates.map do |polygon|
+            Polygon.new.send(
+              :cast_value,
+              {
+                coordinates: polygon
+              }
+            )
+          end
+
+          self
+        rescue StandardError => e
+          handle_error(e)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/mysql/point.rb

@@ -36,7 +36,7 @@ module ActiveRecordMysqlSpatial
         alias to_coordinates_sql to_coordinate_sql
 
         def ==(other)
-          x == other.x && y == other.y
+          super && x == other.x && y == other.y
         end
 
         private
@@ -47,21 +47,25 @@ module ActiveRecordMysqlSpatial
 
           @raw = Geometry.from_coordinates(coordinate, type: :point).as_binary if create_raw
 
-          @x, @y = if coordinate.is_a?(Array) && coordinate.present?
-                     [coordinate[0], coordinate[1]]
-                   elsif value.is_a?(Array)
-                     [value[0], value[1]]
-                   elsif value.is_a?(Hash)
-                     [value[:x] || value['x'], value[:y] || value['y']]
+          @x, @y = if coordinate.present?
+                     drill_value(coordinate)
                    else
-                     [nil, nil]
+                     drill_value(value)
                    end
 
           self
         rescue StandardError => e
-          @error = e.message
+          handle_error(e)
+        end
 
-          self
+        def drill_value(value)
+          if value.is_a?(Array)
+            [value[0], value[1]]
+          elsif value.is_a?(Hash)
+            [value[:x] || value['x'], value[:y] || value['y']]
+          else
+            [nil, nil]
+          end
         end
       end
     end

data/lib/active_record_mysql_spatial/active_record/mysql/polygon.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'linestring'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Polygon < Base
+        attr_accessor :items
+
+        def type
+          :polygon
+        end
+
+        def to_sql
+          return nil if @items.blank?
+
+          "Polygon(#{to_coordinates_sql})"
+        end
+
+        def to_coordinates_sql
+          items.map { |linestring| "(#{linestring.to_coordinates_sql})" }.join(', ')
+        end
+
+        def ==(other)
+          return false if super == false
+
+          items.each_with_index do |item, index|
+            return false if item != other.items[index]
+          end
+
+          true
+        end
+
+        private
+
+        def cast_value(value)
+          @raw = value
+          coordinates, create_raw = extract_coordinates(value)
+
+          @raw = Geometry.from_coordinates(coordinates, type: :polygon).as_binary if create_raw
+
+          @items = coordinates.map do |linestring|
+            Linestring.new.send(
+              :cast_value,
+              {
+                coordinates: linestring
+              }
+            )
+          end
+
+          self
+        rescue StandardError => e
+          handle_error(e)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/native_types.rb

@@ -14,11 +14,26 @@ module ActiveRecordMysqlSpatial
               point: {
                 name: 'point'
               },
+              polygon: {
+                name: 'polygon'
+              },
               linestring: {
                 name: 'linestring'
               },
+              multipoint: {
+                name: 'multipoint'
+              },
+              multipolygon: {
+                name: 'multipolygon'
+              },
               multilinestring: {
                 name: 'multilinestring'
+              },
+              geomcollection: {
+                name: 'geomcollection'
+              },
+              geometrycollection: {
+                name: 'geometrycollection'
               }
             )
           end

data/lib/active_record_mysql_spatial/active_record/quoting.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'mysql/linestring'
-require_relative 'mysql/multilinestring'
-require_relative 'mysql/point'
+require_relative 'mysql/base'
 
 module ActiveRecordMysqlSpatial
   module ActiveRecord
     module Quoting
       def quote(value)
         case value
-        when MySQL::Linestring, MySQL::Multilinestring, MySQL::Point
+        when MySQL::Base
           quote_geom(value)
         else
           super

data/lib/active_record_mysql_spatial/active_record/register_types.rb

@@ -2,9 +2,13 @@
 
 require 'active_support/concern'
 
+require_relative 'mysql/geometrycollection'
 require_relative 'mysql/linestring'
 require_relative 'mysql/multilinestring'
+require_relative 'mysql/multipoint'
+require_relative 'mysql/multipolygon'
 require_relative 'mysql/point'
+require_relative 'mysql/polygon'
 
 module ActiveRecordMysqlSpatial
   module ActiveRecord
@@ -18,8 +22,13 @@ module ActiveRecordMysqlSpatial
 
             def custom_initialize_type_map(type_map)
               type_map.register_type('point', MySQL::Point.new)
+              type_map.register_type('polygon', MySQL::Polygon.new)
               type_map.register_type('linestring', MySQL::Linestring.new)
+              type_map.register_type('multipoint', MySQL::Multipoint.new)
+              type_map.register_type('multipolygon', MySQL::Multipolygon.new)
               type_map.register_type('multilinestring', MySQL::Multilinestring.new)
+              type_map.register_type('geomcollection', MySQL::Geometrycollection.new)
+              type_map.register_type('geometrycollection', MySQL::Geometrycollection.new)
             end
           end
 
@@ -34,8 +43,13 @@ module ActiveRecordMysqlSpatial
         end
 
         ::ActiveRecord::Type.register(:point, MySQL::Point, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:polygon, MySQL::Polygon, adapter: :mysql2)
         ::ActiveRecord::Type.register(:linestring, MySQL::Linestring, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:multipoint, MySQL::Multipoint, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:multipolygon, MySQL::Multipolygon, adapter: :mysql2)
         ::ActiveRecord::Type.register(:multilinestring, MySQL::Multilinestring, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:geomcollection, MySQL::Geometrycollection, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:geometrycollection, MySQL::Geometrycollection, adapter: :mysql2)
       end
     end
   end

data/lib/active_record_mysql_spatial/geometry.rb

@@ -11,6 +11,10 @@ module ActiveRecordMysqlSpatial
         send("#{type}_from_coords", coordinates)
       end
 
+      def from_geometries(geometries)
+        geometrycollection_from_geometries(geometries)
+      end
+
       def from_text(value)
         cartesian_factory.parse_wkt(value)
       rescue StandardError
@@ -18,32 +22,69 @@ module ActiveRecordMysqlSpatial
       end
 
       def valid_spatial?(value)
-        point?(value) || linestring?(value) || multilinestring?(value)
+        point?(value) ||
+          linestring?(value) ||
+          multilinestring?(value) ||
+          multipoint?(value) ||
+          polygon?(value) ||
+          multipolygon?(value) ||
+          geometrycollection?(value)
       end
 
       def point?(value)
-        /^point\(/i.match?(value)
+        /^point*.\(/i.match?(value)
       end
 
       def linestring?(value)
-        /^linestring\(/i.match?(value)
+        /^linestring*.\(/i.match?(value)
       end
 
       def multilinestring?(value)
-        /^multilinestring\(/i.match?(value)
+        /^multilinestring*.\(/i.match?(value)
+      end
+
+      def multipoint?(value)
+        /^multipoint*.\(/i.match?(value)
+      end
+
+      def polygon?(value)
+        /^polygon*.\(/i.match?(value)
+      end
+
+      def multipolygon?(value)
+        /^multipolygon*.\(/i.match?(value)
+      end
+
+      def geometrycollection?(value)
+        /^geometrycollection*.\(/i.match?(value)
       end
 
       private
 
       def point_from_coords(coordinate)
-        x, y = coordinate
+        x, y = if coordinate.is_a?(Array)
+                 coordinate
+               else
+                 [
+                   coordinate[:x] || coordinate['x'],
+                   coordinate[:y] || coordinate['y']
+                 ]
+               end
 
         cartesian_factory.point(x, y)
       end
 
+      def multipoint_from_coords(coordinates)
+        points = coordinates.map do |coordinate|
+          point_from_coords(coordinate)
+        end
+
+        cartesian_factory.multi_point(points)
+      end
+
       def linestring_from_coords(coordinates)
-        points = coordinates.map do |x, y|
-          cartesian_factory.point(x, y)
+        points = coordinates.map do |coordinate|
+          point_from_coords(coordinate)
         end
 
         cartesian_factory.line_string(points)
@@ -57,6 +98,30 @@ module ActiveRecordMysqlSpatial
         cartesian_factory.multi_line_string(line_strings)
       end
 
+      def polygon_from_coords(coordinates)
+        outer_ring, *inner_rings = coordinates.map do |coordinate|
+          linestring_from_coords(coordinate)
+        end
+
+        cartesian_factory.polygon(outer_ring, inner_rings)
+      end
+
+      def multipolygon_from_coords(coordinates)
+        polygons = coordinates.map do |coordinate|
+          polygon_from_coords(coordinate)
+        end
+
+        cartesian_factory.multi_polygon(polygons)
+      end
+
+      def geometrycollection_from_geometries(geometries)
+        geos = geometries.map do |geometry|
+          send("#{geometry[:type].downcase}_from_coords", geometry[:coordinates] || geometry[:coordinate])
+        end
+
+        cartesian_factory.collection(geos)
+      end
+
       def parser
         @parser ||= RGeo::WKRep::WKBParser.new
       end

data/lib/active_record_mysql_spatial/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordMysqlSpatial
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/active_record_mysql_spatial.rb

@@ -3,9 +3,13 @@
 require 'rgeo'
 
 require_relative 'active_record_mysql_spatial/active_record/column_methods'
+require_relative 'active_record_mysql_spatial/active_record/mysql/geometrycollection'
 require_relative 'active_record_mysql_spatial/active_record/mysql/linestring'
 require_relative 'active_record_mysql_spatial/active_record/mysql/multilinestring'
+require_relative 'active_record_mysql_spatial/active_record/mysql/multipoint'
+require_relative 'active_record_mysql_spatial/active_record/mysql/multipolygon'
 require_relative 'active_record_mysql_spatial/active_record/mysql/point'
+require_relative 'active_record_mysql_spatial/active_record/mysql/polygon'
 require_relative 'active_record_mysql_spatial/active_record/native_types'
 require_relative 'active_record_mysql_spatial/active_record/quoting'
 require_relative 'active_record_mysql_spatial/active_record/register_types'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_mysql_spatial
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alpha
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-09 00:00:00.000000000 Z
+date: 2024-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgeo
@@ -37,15 +37,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
 - README.md
 - Rakefile
 - active_record_mysql_spatial.gemspec
 - lib/active_record_mysql_spatial.rb
 - lib/active_record_mysql_spatial/active_record/column_methods.rb
 - lib/active_record_mysql_spatial/active_record/mysql/base.rb
+- lib/active_record_mysql_spatial/active_record/mysql/geometrycollection.rb
 - lib/active_record_mysql_spatial/active_record/mysql/linestring.rb
 - lib/active_record_mysql_spatial/active_record/mysql/multilinestring.rb
+- lib/active_record_mysql_spatial/active_record/mysql/multipoint.rb
+- lib/active_record_mysql_spatial/active_record/mysql/multipolygon.rb
 - lib/active_record_mysql_spatial/active_record/mysql/point.rb
+- lib/active_record_mysql_spatial/active_record/mysql/polygon.rb
 - lib/active_record_mysql_spatial/active_record/native_types.rb
 - lib/active_record_mysql_spatial/active_record/quoting.rb
 - lib/active_record_mysql_spatial/active_record/register_types.rb