active_record_mysql_spatial 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1fb8466cfa0fa405fd35472dfa05122712db0dc27b7a3daad65d6c0329736ab
+  data.tar.gz: c58c26a2abff58ae9d9c32e710b7898db5648a5980db891deb71911b82336140
+SHA512:
+  metadata.gz: ded6ba2548871b914758b5306c8b0b6b68f3922e059c3895e2e938e7a7fe6cb781f42e084d46b9871ba71e7a429097f2b9ed52d66b5e415f1bd2132b9d17b7c1
+  data.tar.gz: 162ab35dd4901102eb470bf71c7086ea1febd6de8d24695415a4be983df2b51cf1bb0399b0dac7e9fa1b0aca32e7cbea945fd588ffbcfd14e2f1de27b14876e0

data/README.md

@@ -0,0 +1,35 @@
+# ActiveRecordMysqlSpatial
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/active_record_mysql_spatial`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_record_mysql_spatial.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/active_record_mysql_spatial.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'lib/active_record_mysql_spatial/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'active_record_mysql_spatial'
+  spec.version = ActiveRecordMysqlSpatial::VERSION
+  spec.authors = ['Alpha']
+  spec.email = ['alphanolucifer@gmail.com']
+
+  spec.summary = 'MySQL Spatial Data Types for ActiveRecord'
+  spec.description = 'MySQL Spatial Data Types for ActiveRecord'
+  spec.homepage = 'https://github.com/zgid123/active_record_mysql_spatial'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(
+          *%w[
+            bin/
+            test/
+            spec/
+            features/
+            .git
+            .circleci
+            appveyor
+            examples/
+            Gemfile
+            .rubocop.yml
+            .vscode/settings.json
+            LICENSE.txt
+            lefthook.yml
+          ]
+        )
+    end
+  end
+
+  spec.require_paths = ['lib']
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+
+  spec.add_runtime_dependency 'rgeo', '~> 3.0', '>= 3.0.1'
+end

data/lib/active_record_mysql_spatial/active_record/column_methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module ColumnMethods
+      extend ActiveSupport::Concern
+
+      included do
+        define_column_methods :point,
+                              :linestring,
+                              :multilinestring
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Base < ::ActiveRecord::Type::Json
+        attr_reader :raw,
+                    :error
+
+        def type
+          raise NotImplementedError
+        end
+
+        def deserialize(value)
+          return value if value.is_a?(self.class)
+
+          cast_value(value)
+        end
+
+        def serialize(value)
+          if value.is_a?(self.class)
+            value
+          else
+            return unless valid_hash?(value)
+
+            cast_value(value)
+          end
+        end
+
+        def to_sql
+          raise NotImplementedError
+        end
+
+        def to_coordinates_sql
+          raise NotImplementedError
+        end
+
+        private
+
+        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 [[], false] unless attributes.is_a?(String)
+
+          if attributes.encoding.to_s == 'ASCII-8BIT'
+            linestring = Geometry.parse_bin(attributes)
+
+            [linestring.coordinates, false]
+          elsif Geometry.valid_spatial?(attributes)
+            spatial_data = Geometry.from_text(attributes)
+
+            [spatial_data.coordinates, true]
+          else
+            parsed_json = ::ActiveSupport::JSON.decode(attributes)
+
+            [parsed_json['coordinates'] || [], true]
+          end
+        end
+
+        def valid_hash?(attributes, type: :linestring)
+          return false unless attributes.is_a?(Hash)
+
+          valid_coord_hash = attributes.key?(:coordinates) || attributes.key?('coordinates') || attributes.key?(:coordinate) || attributes.key?('coordinate')
+
+          return valid_coord_hash unless type == :point
+
+          valid_coord_hash || attributes.key?(:x) || attributes.key?('x') || attributes.key?(:y) || attributes.key?('y')
+        end
+
+        def drill_coordinates(attributes)
+          attributes[:coordinates].presence || attributes['coordinates'].presence || attributes[:coordinate].presence || attributes['coordinate']
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'linestring'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Multilinestring < Base
+        attr_accessor :items
+
+        def type
+          :multilinestring
+        end
+
+        def to_sql
+          return nil if @items.blank?
+
+          "MultiLineString(#{to_coordinates_sql})"
+        end
+
+        def to_coordinates_sql
+          items.map { |linestring| "(#{linestring.to_coordinates_sql})" }.join(',')
+        end
+
+        def ==(other)
+          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: :multilinestring).as_binary if create_raw
+
+          @items = coordinates.map do |linestring|
+            Linestring.new.send(
+              :cast_value,
+              {
+                coordinates: linestring
+              }
+            )
+          end
+
+          self
+        rescue StandardError => e
+          @error = e.message
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module MySQL
+      class Point < Base
+        attr_reader :x,
+                    :y
+
+        def type
+          :point
+        end
+
+        def serialize(value)
+          if value.is_a?(Point)
+            value
+          else
+            return unless valid_hash?(value, type: :point)
+
+            cast_value(value)
+          end
+        end
+
+        def to_sql
+          return nil if @x.nil? || @y.nil?
+
+          "Point(#{to_coordinate_sql})"
+        end
+
+        def to_coordinate_sql
+          return nil if @x.nil? || @y.nil?
+
+          "#{@x} #{@y}"
+        end
+
+        alias to_coordinates_sql to_coordinate_sql
+
+        def ==(other)
+          x == other.x && y == other.y
+        end
+
+        private
+
+        def cast_value(value)
+          @raw = value
+          coordinate, create_raw = extract_coordinates(value, type: :point)
+
+          @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']]
+                   else
+                     [nil, nil]
+                   end
+
+          self
+        rescue StandardError => e
+          @error = e.message
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/native_types.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module NativeTypes
+      extend ActiveSupport::Concern
+
+      included do
+        class_eval do
+          def native_database_types
+            self.class.const_get('NATIVE_DATABASE_TYPES').merge(
+              point: {
+                name: 'point'
+              },
+              linestring: {
+                name: 'linestring'
+              },
+              multilinestring: {
+                name: 'multilinestring'
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/quoting.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'mysql/linestring'
+require_relative 'mysql/multilinestring'
+require_relative 'mysql/point'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module Quoting
+      def quote(value)
+        case value
+        when MySQL::Linestring, MySQL::Multilinestring, MySQL::Point
+          quote_geom(value)
+        else
+          super
+        end
+      end
+
+      private
+
+      def quote_geom(value)
+        spatial_raw = value.to_sql
+
+        return 'NULL' if spatial_raw.blank?
+
+        "ST_GeomFromText('#{spatial_raw}')"
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/active_record/register_types.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+require_relative 'mysql/linestring'
+require_relative 'mysql/multilinestring'
+require_relative 'mysql/point'
+
+module ActiveRecordMysqlSpatial
+  module ActiveRecord
+    module RegisterTypes
+      extend ActiveSupport::Concern
+
+      included do
+        class_eval do
+          class << self
+            private
+
+            def custom_initialize_type_map(type_map)
+              type_map.register_type('point', MySQL::Point.new)
+              type_map.register_type('linestring', MySQL::Linestring.new)
+              type_map.register_type('multilinestring', MySQL::Multilinestring.new)
+            end
+          end
+
+          remove_const('TYPE_MAP')
+          const_set(
+            'TYPE_MAP',
+            ::ActiveRecord::Type::TypeMap.new.tap do |m|
+              initialize_type_map(m)
+              custom_initialize_type_map(m)
+            end
+          )
+        end
+
+        ::ActiveRecord::Type.register(:point, MySQL::Point, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:linestring, MySQL::Linestring, adapter: :mysql2)
+        ::ActiveRecord::Type.register(:multilinestring, MySQL::Multilinestring, adapter: :mysql2)
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/geometry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ActiveRecordMysqlSpatial
+  class Geometry
+    class << self
+      def parse_bin(bin)
+        parser.parse(bin[4..])
+      end
+
+      def from_coordinates(coordinates, type: :linestring)
+        send("#{type}_from_coords", coordinates)
+      end
+
+      def from_text(value)
+        cartesian_factory.parse_wkt(value)
+      rescue StandardError
+        nil
+      end
+
+      def valid_spatial?(value)
+        point?(value) || linestring?(value) || multilinestring?(value)
+      end
+
+      def point?(value)
+        /^point\(/i.match?(value)
+      end
+
+      def linestring?(value)
+        /^linestring\(/i.match?(value)
+      end
+
+      def multilinestring?(value)
+        /^multilinestring\(/i.match?(value)
+      end
+
+      private
+
+      def point_from_coords(coordinate)
+        x, y = coordinate
+
+        cartesian_factory.point(x, y)
+      end
+
+      def linestring_from_coords(coordinates)
+        points = coordinates.map do |x, y|
+          cartesian_factory.point(x, y)
+        end
+
+        cartesian_factory.line_string(points)
+      end
+
+      def multilinestring_from_coords(coordinates)
+        line_strings = coordinates.map do |coordinate|
+          linestring_from_coords(coordinate)
+        end
+
+        cartesian_factory.multi_line_string(line_strings)
+      end
+
+      def parser
+        @parser ||= RGeo::WKRep::WKBParser.new
+      end
+
+      def cartesian_factory
+        @cartesian_factory ||= RGeo::Cartesian::Factory.new
+      end
+    end
+  end
+end

data/lib/active_record_mysql_spatial/version.rb

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

data/lib/active_record_mysql_spatial.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rgeo'
+
+require_relative 'active_record_mysql_spatial/active_record/column_methods'
+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/point'
+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'
+require_relative 'active_record_mysql_spatial/geometry'
+require_relative 'active_record_mysql_spatial/version'
+
+module ActiveRecordMysqlSpatial
+  class Error < StandardError; end
+
+  class Railtie < Rails::Railtie
+    initializer 'active_record.override_mysql_spatial' do
+      ::ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.include ActiveRecordMysqlSpatial::ActiveRecord::Quoting
+        ::ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.include ActiveRecordMysqlSpatial::ActiveRecord::NativeTypes
+
+        ::ActiveRecord::ConnectionAdapters::Mysql2Adapter.include ActiveRecordMysqlSpatial::ActiveRecord::RegisterTypes
+
+        ::ActiveRecord::ConnectionAdapters::MySQL::Table.include ActiveRecordMysqlSpatial::ActiveRecord::ColumnMethods
+
+        ::ActiveRecord::ConnectionAdapters::MySQL::TableDefinition.include ActiveRecordMysqlSpatial::ActiveRecord::ColumnMethods
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: active_record_mysql_spatial
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alpha
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rgeo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+description: MySQL Spatial Data Types for ActiveRecord
+email:
+- alphanolucifer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- 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/linestring.rb
+- lib/active_record_mysql_spatial/active_record/mysql/multilinestring.rb
+- lib/active_record_mysql_spatial/active_record/mysql/point.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
+- lib/active_record_mysql_spatial/geometry.rb
+- lib/active_record_mysql_spatial/version.rb
+homepage: https://github.com/zgid123/active_record_mysql_spatial
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zgid123/active_record_mysql_spatial
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.13
+signing_key:
+specification_version: 4
+summary: MySQL Spatial Data Types for ActiveRecord
+test_files: []