activerecord-spatial 1.0.0 → 2.0.0

data/Gemfile

@@ -2,20 +2,19 @@ source 'https://rubygems.org'
 
 gemspec
 
-if RUBY_PLATFORM == "java"
-  gem "activerecord-jdbcpostgresql-adapter"
+if RUBY_PLATFORM == 'java'
+  gem 'activerecord-jdbcpostgresql-adapter'
 else
-  gem "pg"
+  gem 'pg'
 end
 
-gem "rdoc", "~> 3.12"
-gem "rake", "~> 10.0"
-gem "minitest"
-gem "minitest-reporters"
-gem "guard-minitest"
-gem "simplecov"
-
-if File.exists?('Gemfile.local')
-  instance_eval File.read('Gemfile.local')
-end
+gem 'activerecord-testcase'
+gem 'guard'
+gem 'guard-minitest'
+gem 'minitest'
+gem 'minitest-reporters'
+gem 'rake'
+gem 'rdoc'
+gem 'simplecov'
 
+instance_eval File.read('Gemfile.local') if File.exist?('Gemfile.local')

data/Guardfile

@@ -1,17 +1,14 @@
 
-guard 'minitest', :test_folders => 'test', :test_file_patterns => '*_tests.rb' do
-  watch(%r|^test/(.+)_tests\.rb|)
+guard 'minitest', test_folders: 'test', test_file_patterns: '*_tests.rb' do
+  watch(%r{^test/(.+)_tests\.rb})
 
-  watch(%r|^lib/(.*)([^/]+)\.rb|) do |m|
-    "test/#{m[1]}#{m[2]}_tests.rb"
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$}) do |m|
+    "test/#{m[2]}_tests.rb"
   end
 
-  watch(%r|^test/test_helper\.rb|) do
-    "test"
+  watch(%r{^test/test_helper\.rb}) do
+    'test'
   end
 end
 
-if File.exists?('Guardfile.local')
-  instance_eval File.read('Guardfile.local')
-end
-
+instance_eval File.read('Guardfile.local') if File.exist?('Guardfile.local')

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2016 J Smith <dark.panda@gmail.com>
+Copyright (c) 2010-2017 J Smith <dark.panda@gmail.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.rdoc

@@ -107,31 +107,21 @@ See the test/database.yml file for example settings.
 
 == ActiveRecord Versions Supported
 
-We're starting to standardize on Rails 3+ for our purposes, so future versions
-this gem function on versions of Rails 3 and above. To use spatial scopes on
+We're starting to standardize on Rails 5 for our purposes, so future versions
+this gem function on versions of Rails 5 and above. To use spatial scopes on
 previous versions of ActiveRecord, see our geos-extensions gem available at
 https://github.com/dark-panda/geos-extensions . We have pulled the ActiveRecord
 extensions out of that gem and are instead packaging them here, thus allowing
 you to use the actual Geos extensions in an unfettered way. If you wish to
-use the spatial extensions with versions of Rails prior to 3, see versions of
-the geos-extensions gem prior to version 0.3.0 where the split occured.
-
-=== Note About ActiveRecord 4.0.0
-
-Rails 4.0.0 introducted a backwards incompatible change involving `order`
-scopes where `ORDER BY` would be added in the opposite order compared to
-previous versions of Rails. This change was reverted in Rails 4.0.1. Because
-the change only lasted for a single version, we have decided that we will
-not be supporting Rails 4.0.0 and will only support versions of Rails that
-feature `order` scopes that are consistent with the behaviour prior to Rails
-4.0.0. This includes Rails 4.0.1 and above.
+use the spatial extensions with versions of Rails prior to 5, see versions of
+the ActiveRecordSpatial gem prior to version 1.0.0.
 
 == PostGIS and PostgreSQL Versions Supported
 
-As of this writing, things look good for PostgreSQL 9.1 and 9.2 for both
-PostGIS 1.5 and 2.0. Some features are only available in PostGIS 2.0, such
-as the +st_3dintersects+ scope and the like, as that spatial relationship
-function was added in PostGIS 2.0.
+As of this writing, things we test on PostgreSQL 9.4 and PostGIS 2.1+.
+Some features are only available in PostGIS 2.0, such as the +st_3dintersects+
+scope and the like, as that spatial relationship function was added in PostGIS
+2.0.
 
 PostgreSQL 9.0 and below are currently not supported as some of the SQL we
 produce to create the spatial queries is not supported in older PostgreSQL
@@ -176,4 +166,3 @@ most projects.
 
 This gem is licensed under an MIT-style license. See the +MIT-LICENSE+ file for
 details.
-

data/Rakefile

@@ -7,7 +7,7 @@ require 'rake/testtask'
 require 'rdoc/task'
 require 'bundler/gem_tasks'
 
-$:.push File.expand_path(File.dirname(__FILE__), 'lib')
+$LOAD_PATH.push File.expand_path(File.dirname(__FILE__), 'lib')
 
 version = ActiveRecordSpatial::VERSION
 
@@ -26,3 +26,4 @@ Rake::RDocTask.new do |t|
   t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
 end
 
+task default: :test

data/activerecord-spatial.gemspec

@@ -3,25 +3,24 @@
 require File.expand_path('../lib/activerecord-spatial/version', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = "activerecord-spatial"
+  s.name = 'activerecord-spatial'
   s.version = ActiveRecordSpatial::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["J Smith"]
-  s.description = "ActiveRecord Spatial gives AR the ability to work with PostGIS columns."
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['J Smith']
+  s.description = 'ActiveRecord Spatial gives AR the ability to work with PostGIS columns.'
   s.summary = s.description
-  s.email = "dark.panda@gmail.com"
-  s.license = "MIT"
+  s.email = 'dark.panda@gmail.com'
+  s.license = 'MIT'
   s.extra_rdoc_files = [
-    "README.rdoc"
+    'README.rdoc'
   ]
-  s.files = `git ls-files`.split($\)
+  s.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
-  s.homepage = "https://github.com/dark-panda/activerecord-spatial"
-  s.require_paths = ["lib"]
+  s.homepage = 'https://github.com/dark-panda/activerecord-spatial'
+  s.require_paths = ['lib']
 
-  s.add_dependency("rails", [">= 3.2", "!= 4.0.0"])
-  s.add_dependency("geos-extensions", [">= 0.3.0.dev"])
+  s.add_dependency('rails', ['>= 5.0'])
+  s.add_dependency('geos-extensions', ['>= 0.5'])
 end
-

data/lib/activerecord-spatial/active_record/connection_adapters/postgresql/adapter_extensions/active_record.rb

@@ -0,0 +1,46 @@
+
+module ActiveRecord
+  module Type
+    class Geometry < Value
+      def type
+        :geometry
+      end
+    end
+
+    class Geography < Value
+      def type
+        :geography
+      end
+    end
+  end
+
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID
+        class Geometry < Type::Geometry
+        end
+
+        class Geography < Type::Geography
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:geometry] = {
+  name: 'geometry'
+}
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:geometry] = {
+  name: 'geography'
+}
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+  prepend(Module.new do
+    def initialize_type_map(type_map)
+      super
+      type_map.register_type 'geometry', ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Geometry.new
+      type_map.register_type 'geography', ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Geography.new
+    end
+  end)
+end

data/lib/activerecord-spatial/active_record/connection_adapters/postgresql/adapter_extensions.rb

@@ -1,26 +1,15 @@
 
 require 'active_record/connection_adapters/postgresql_adapter'
+require 'activerecord-spatial/active_record/connection_adapters/postgresql/adapter_extensions/active_record'
+
+module ActiveRecordSpatial
+  autoload :POSTGIS, 'activerecord-spatial/active_record/connection_adapters/postgresql/postgis'
+  autoload :UNKNOWN_SRID, 'activerecord-spatial/active_record/connection_adapters/postgresql/unknown_srid'
+  autoload :UNKNOWN_SRIDS, 'activerecord-spatial/active_record/connection_adapters/postgresql/unknown_srid'
+end
 
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLColumn
-      def simplified_type_with_spatial_type(field_type)
-        case field_type
-          # This is a special internal type used by PostgreSQL. In this case,
-          # it is being used by the `geography_columns` view in PostGIS.
-          when 'name'
-            :string
-          when /^geometry(\(|$)/
-            :geometry
-          when /^geography(\(|$)/
-            :geography
-          else
-            simplified_type_without_spatial_type(field_type)
-        end
-      end
-      alias_method_chain :simplified_type, :spatial_type
-    end
-
     class PostgreSQLAdapter
       def geometry_columns?
         true
@@ -29,26 +18,6 @@ module ActiveRecord
       def geography_columns?
         ActiveRecordSpatial::POSTGIS[:lib] >= '1.5'
       end
-
-      if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID)
-        module OID
-          class Spatial < Type
-            def type_cast(value)
-              value
-            end
-          end
-
-          register_type 'geometry', OID::Spatial.new
-          register_type 'geography', OID::Spatial.new
-        end
-      end
     end
   end
 end
-
-module ActiveRecordSpatial
-  autoload :POSTGIS, 'activerecord-spatial/active_record/connection_adapters/postgresql/postgis'
-  autoload :UNKNOWN_SRID, 'activerecord-spatial/active_record/connection_adapters/postgresql/unknown_srid'
-  autoload :UNKNOWN_SRIDS, 'activerecord-spatial/active_record/connection_adapters/postgresql/unknown_srid'
-end
-

data/lib/activerecord-spatial/active_record/connection_adapters/postgresql/postgis.rb

@@ -1,16 +1,16 @@
 
 module ActiveRecordSpatial
   POSTGIS = begin
-    if (version_string = ::ActiveRecord::Base.connection.select_rows("SELECT postgis_full_version()").flatten.first).present?
+    if (version_string = ::ActiveRecord::Base.connection.select_rows('SELECT postgis_full_version()').flatten.first).present?
       hash = {
-        :use_stats => version_string =~ /USE_STATS/
+        use_stats: version_string =~ /USE_STATS/
       }
 
       {
-        :lib => /POSTGIS="([^"]+)"/,
-        :geos => /GEOS="([^"]+)"/,
-        :proj => /PROJ="([^"]+)"/,
-        :libxml => /LIBXML="([^"]+)"/
+        lib: /POSTGIS="([^"]+)"/,
+        geos: /GEOS="([^"]+)"/,
+        proj: /PROJ="([^"]+)"/,
+        libxml: /LIBXML="([^"]+)"/
       }.each do |k, v|
         hash[k] = version_string.scan(v).flatten.first
       end
@@ -21,4 +21,3 @@ module ActiveRecordSpatial
     end
   end
 end
-

data/lib/activerecord-spatial/active_record/connection_adapters/postgresql/unknown_srid.rb

@@ -3,13 +3,13 @@ module ActiveRecordSpatial
   UNKNOWN_SRIDS = begin
     if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
       {
-        :geography => 0,
-        :geometry  => 0
+        geography: 0,
+        geometry: 0
       }.freeze
     else
       {
-        :geography =>  0,
-        :geometry  => -1
+        geography:  0,
+        geometry: -1
       }.freeze
     end
   end
@@ -18,4 +18,3 @@ module ActiveRecordSpatial
     ActiveRecordSpatial::UNKNOWN_SRIDS[:geometry]
   end
 end
-

data/lib/activerecord-spatial/active_record/models/geography_column.rb

@@ -10,8 +10,7 @@ module ActiveRecordSpatial
     end
 
     def spatial_column
-      self.f_geography_column
+      f_geography_column
     end
   end
 end
-

data/lib/activerecord-spatial/active_record/models/geometry_column.rb

@@ -10,8 +10,7 @@ module ActiveRecordSpatial
     end
 
     def spatial_column
-      self.f_geometry_column
+      f_geometry_column
     end
   end
 end
-

data/lib/activerecord-spatial/active_record/models/spatial_column.rb

@@ -11,7 +11,7 @@ module ActiveRecordSpatial
       self.inheritance_column = 'nonexistent_column_name_type'
 
       belongs_to :spatial_ref_sys,
-        :foreign_key => :srid
+        foreign_key: :srid
     end
 
     def readonly?
@@ -19,4 +19,3 @@ module ActiveRecordSpatial
     end
   end
 end
-

data/lib/activerecord-spatial/active_record/models/spatial_ref_sys.rb

@@ -5,16 +5,15 @@ module ActiveRecordSpatial
     self.primary_key = 'srid'
 
     has_many :geometry_columns,
-      :foreign_key => :srid,
-      :inverse_of => :spatial_ref_sys
+      foreign_key: :srid,
+      inverse_of: :spatial_ref_sys
 
     has_many :geography_columns,
-      :foreign_key => :srid,
-      :inverse_of => :spatial_ref_sys
+      foreign_key: :srid,
+      inverse_of: :spatial_ref_sys
 
     def spatial_columns
-      self.geometry_columns + self.geography_columns
+      geometry_columns + geography_columns
     end
   end
 end
-

data/lib/activerecord-spatial/active_record.rb

@@ -11,4 +11,3 @@ module ActiveRecordSpatial
 end
 
 require 'activerecord-spatial/associations'
-

data/lib/activerecord-spatial/associations/active_record.rb

@@ -1,146 +1,88 @@
-# encoding: UTF-8
 
 module ActiveRecord
-  module Associations
-    class Builder::Spatial < Builder::HasMany #:nodoc:
-      def macro
-        SPATIAL_MACRO
-      end
-
-      def valid_options
-        super + VALID_SPATIAL_OPTIONS - INVALID_SPATIAL_OPTIONS
-      end
-    end
-
+  module Associations #:nodoc:
     class Preloader #:nodoc:
       class SpatialAssociation < HasMany #:nodoc:
-        def records_for(ids)
-          table_name = reflection.quoted_table_name
-          join_name = model.quoted_table_name
-          column = %{#{SPATIAL_JOIN_QUOTED_NAME}.#{model.quoted_primary_key}}
-          geom = {
-            :class => model,
-            :table_alias => SPATIAL_JOIN_NAME
-          }
-
-          if reflection.options[:geom].is_a?(Hash)
-            geom.merge!(reflection.options[:geom])
-          else
-            geom[:column] = reflection.options[:geom]
-          end
+        private
 
-          scoped = scope.
-            select(%{array_to_string(array_agg(#{column}), ',') AS "#{SPATIAL_FIELD_ALIAS}"}).
-            joins(
-              "INNER JOIN #{join_name} AS #{SPATIAL_JOIN_QUOTED_NAME} ON (" <<
-                klass.send("st_#{reflection.options[:relationship]}",
-                  geom,
-                  (reflection.options[:scope_options] || {}).merge(
-                    :column => reflection.options[:foreign_geom]
-                  )
-                ).where_values.join(' AND ') <<
-              ")"
-            ).
-            where(model.arel_table.alias(SPATIAL_JOIN_NAME)[model.primary_key].in(ids)).
-            group(table[klass.primary_key])
-
-          if reflection.options[:conditions]
-            scoped = scoped.where(reflection.options[:conditions])
-          end
+          def load_records(&block)
+            return {} if owner_keys.empty?
 
-          scoped
-        end
-      end
-    end
+            slices = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+            @preloaded_records = slices.flat_map do |slice|
+              records_for(slice).load(&block)
+            end
 
-    class AssociationScope #:nodoc:
-      def add_constraints_with_spatial(scope)
-        return add_constraints_without_spatial(scope) if !self.association.is_a?(SpatialAssociation)
-
-        tables = construct_tables
-
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
-
-          geom_options = {
-            :class => self.association.klass
-          }
-
-          if self.association.geom.is_a?(Hash)
-            geom_options.merge!(
-              :value => owner[self.association.geom[:name]]
-            )
-            geom_options.merge!(self.association.geom)
-          else
-            geom_options.merge!(
-              :value => owner[self.association.geom],
-              :name => self.association.geom
-            )
+            @preloaded_records.each_with_object({}) do |record, memo|
+              keys = record[association_key_name].split(',')
+              keys.each do |key|
+                memo[key] ||= []
+                memo[key] << record
+              end
+            end
           end
 
-          if reflection == chain.last
-            scope = scope.send("st_#{self.association.relationship}", geom_options, self.association.scope_options)
-
-            if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
-            end
-          else
-            constraint = scope.where(
-              scope.send(
-                "st_#{self.association.relationship}",
-                owner[self.association.foreign_geom],
-                self.association.scope_options
-              ).where_values
-            ).join(' AND ')
-
-            if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = table[reflection.type].eq(type).and(constraint)
+          def associated_records_by_owner(_preloader)
+            records = load_records do |record|
+              record[association_key_name].split(',').each do |key|
+                owner = owners_by_key[convert_key(key)]
+                association = owner.association(reflection.name)
+                association.set_inverse_instance(record)
+              end
             end
 
-            scope = scope.joins(join(foreign_table, constraint))
+            owners.each_with_object({}) do |owner, result|
+              result[owner] = records[convert_key(owner[owner_key_name])] || []
+            end
           end
+      end
+    end
 
-          if reflection.options[:conditions].present?
-            scope = scope.where(reflection.options[:conditions])
-          end
+    class SpatialAssociation < HasManyAssociation #:nodoc:
+      def association_scope
+        return unless klass
 
-          # Exclude the scope of the association itself, because that
-          # was already merged in the #scope method.
-          scope_chain[i].each do |scope_chain_item|
-            klass = i == 0 ? self.klass : reflection.klass
-            item  = eval_scope(klass, scope_chain_item)
+        @association_scope ||= SpatialAssociationScope.scope(self, klass.connection)
+      end
 
-            if scope_chain_item == self.reflection.scope
-              scope.merge! item.except(:where, :includes)
-            end
+      private
 
-            scope.includes! item.includes_values
-            scope.where_values += item.where_values
-            scope.order_values |= item.order_values
-          end
+        def get_records
+          scope.to_a
         end
+    end
 
-        scope
+    class SpatialAssociationScope < AssociationScope #:nodoc:
+      INSTANCE = create
+
+      class << self
+        def scope(association, connection)
+          INSTANCE.scope(association, connection)
+        end
       end
-      alias_method_chain :add_constraints, :spatial
-    end
-  end
-end
 
+      def last_chain_scope(scope, table, reflection, owner, assoc_klass)
+        geom_options = {
+          class: assoc_klass
+        }
+
+        if reflection.geom.is_a?(Hash)
+          geom_options[:value] = owner[reflection.geom[:name]]
+          geom_options.merge!(reflection.geom)
+        else
+          geom_options[:value] = owner[reflection.geom]
+          geom_options[:name] = reflection.geom
+        end
 
-module ActiveRecordSpatial::Associations
-  module ClassMethods #:nodoc:
-    def has_many_spatially(name, *args, &extension)
-      options = build_options(args.extract_options!)
-      scope = args.first
+        scope = scope.send("st_#{reflection.relationship}", geom_options, reflection.scope_options)
 
-      if !ActiveRecordSpatial::SpatialScopeConstants::RELATIONSHIPS.include?(options[:relationship].to_s)
-        raise ArgumentError.new(%{Invalid spatial relationship "#{options[:relationship]}", expected one of #{ActiveRecordSpatial::SpatialScopeConstants::RELATIONSHIPS.inspect}})
-      end
+        if reflection.type
+          polymorphic_type = transform_value(owner.class.base_class.name)
+          scope = scope.where(table.name => { reflection.type => polymorphic_type })
+        end
 
-      ActiveRecord::Associations::Builder::Spatial.build(self, name, scope, options, &extension)
+        scope
+      end
     end
   end
 end
-