activerecord-spatial 1.0.0 → 2.0.0

data/test/test_helper.rb

@@ -4,16 +4,19 @@ require 'simplecov'
 SimpleCov.command_name('Unit Tests')
 SimpleCov.start do
   add_filter '/test/'
+  add_filter '/.bundle/'
 end
 
 require 'rubygems'
 require 'minitest/autorun'
 require 'minitest/reporters'
+require 'rails'
 require 'active_support'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/dependencies'
 require 'active_record'
 require 'active_record/fixtures'
+require 'active_record/test_case'
 require 'logger'
 
 require File.join(File.dirname(__FILE__), %w{ .. lib activerecord-spatial })
@@ -22,11 +25,11 @@ POSTGIS_PATHS = [
   ENV['POSTGIS_PATH'],
   '/opt/local/share/postgresql*/contrib/postgis-*',
   '/usr/share/postgresql*/contrib/postgis-*',
-  '/usr/pgsql-*/share/contrib/postgis-*',
+  '/usr/pgsql-*/share/contrib/postgis-*'
 ].compact
 
 puts "ActiveRecordSpatial #{ActiveRecordSpatial::VERSION}"
-puts "ActiveRecord #{Gem.loaded_specs['activerecord'].version.to_s}"
+puts "ActiveRecord #{Gem.loaded_specs['activerecord'].version}"
 puts "Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
 puts "Geos library #{Geos::VERSION}" if defined?(Geos::VERSION)
 puts "GEOS #{Geos::GEOS_VERSION}"
@@ -35,7 +38,8 @@ if defined?(Geos::FFIGeos)
   puts "Using #{Geos::FFIGeos.geos_library_paths.join(', ')}"
 end
 
-ActiveRecord::Base.logger = Logger.new("debug.log") if ENV['ENABLE_LOGGER']
+ActiveSupport::TestCase.test_order = :random
+ActiveRecord::Base.logger = Logger.new('debug.log') if ENV['ENABLE_LOGGER']
 ActiveRecord::Base.configurations = {
   'arunit' => {}
 }
@@ -46,9 +50,9 @@ ActiveRecord::Base.configurations = {
 }.each do |file|
   file = File.join('test', file)
 
-  next unless File.exists?(file)
+  next unless File.exist?(file)
 
-  configuration = YAML.load(File.read(file))
+  configuration = YAML.safe_load(File.read(file))
 
   if configuration['arunit']
     ActiveRecord::Base.configurations['arunit'].merge!(configuration['arunit'])
@@ -59,17 +63,21 @@ ActiveRecord::Base.configurations = {
   end
 end
 
-ActiveRecord::Base.establish_connection 'arunit'
+ActiveRecord::Base.establish_connection :arunit
 ARBC = ActiveRecord::Base.connection
 
-if postgresql_version = ARBC.select_rows('SELECT version()').first.first
+postgresql_version = ARBC.select_rows('SELECT version()').first.first
+
+if postgresql_version.present?
   puts "PostgreSQL info from version(): #{postgresql_version}"
 end
 
-puts "Checking for PostGIS install"
+puts 'Checking for PostGIS install'
 2.times do
   begin
-    if postgis_version = ActiveRecordSpatial::POSTGIS[:lib]
+    postgis_version = ActiveRecordSpatial::POSTGIS[:lib]
+
+    if postgis_version.present?
       puts "PostGIS info from postgis_full_version(): #{postgis_version}"
       break
     end
@@ -77,9 +85,7 @@ puts "Checking for PostGIS install"
     puts "Trying to install PostGIS. If this doesn't work, you'll have to do this manually!"
 
     plpgsql = ARBC.select_rows(%{SELECT count(*) FROM pg_language WHERE lanname = 'plpgsql'}).first.first.to_i
-    if plpgsql == 0
-      ARBC.execute(%{CREATE LANGUAGE plpgsql})
-    end
+    ARBC.execute(%{CREATE LANGUAGE plpgsql}) if plpgsql.zero?
 
     %w{
       postgis.sql
@@ -105,35 +111,39 @@ class ActiveRecordSpatialTestCase < ActiveRecord::TestCase
 
   REGEXP_WKB_HEX = /[A-Fa-f0-9\s]+/
 
-  POINT_WKT = 'POINT(10 10.01)'
-  POINT_EWKT = 'SRID=4326; POINT(10 10.01)'
-  POINT_EWKT_WITH_DEFAULT = 'SRID=default; POINT(10 10.01)'
-  POINT_WKB = "0101000000000000000000244085EB51B81E052440"
-  POINT_WKB_BIN = "\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
-  POINT_EWKB = "0101000020E6100000000000000000244085EB51B81E052440"
-  POINT_EWKB_BIN = "\x01\x01\x00\x00\x20\xE6\x10\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
-  POINT_G_LAT_LNG = "(10.01, 10)"
-  POINT_G_LAT_LNG_URL_VALUE = "10.01,10"
-
-  POLYGON_WKT = 'POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
-  POLYGON_EWKT = 'SRID=4326; POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
-  POLYGON_WKB = "
+  POINT_WKT = 'POINT(10 10.01)'.freeze
+  POINT_EWKT = 'SRID=4326; POINT(10 10.01)'.freeze
+  POINT_EWKT_WITH_DEFAULT = 'SRID=default; POINT(10 10.01)'.freeze
+  POINT_WKB = '0101000000000000000000244085EB51B81E052440'.freeze
+  POINT_WKB_BIN = "\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40".freeze
+  POINT_EWKB = '0101000020E6100000000000000000244085EB51B81E052440'.freeze
+  POINT_EWKB_BIN = "\x01\x01\x00\x00\x20\xE6\x10\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40".freeze
+  POINT_G_LAT_LNG = '(10.01, 10)'.freeze
+  POINT_G_LAT_LNG_URL_VALUE = '10.01,10'.freeze
+
+  POLYGON_WKT = 'POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'.freeze
+  POLYGON_EWKT = 'SRID=4326; POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'.freeze
+
+  POLYGON_WKB = '
     0103000000010000000500000000000000000000000000000000000000000000000000F
     03F000000000000F03F0000000000000440000000000000044000000000000014400000
     00000000144000000000000000000000000000000000
-  ".gsub(/\s/, '')
+  '.gsub(/\s/, '').freeze
+
   POLYGON_WKB_BIN = [
     "\x01\x03\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00",
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xF0\x3F\x00",
     "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00",
     "\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14",
     "\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-  ].join
-  POLYGON_EWKB = "
+  ].join.freeze
+
+  POLYGON_EWKB = '
     0103000020E610000001000000050000000000000000000000000000000000000000000
     0000000F03F000000000000F03F00000000000004400000000000000440000000000000
     1440000000000000144000000000000000000000000000000000
-  ".gsub(/\s/, '')
+  '.gsub(/\s/, '').freeze
+
   POLYGON_EWKB_BIN = [
     "\x01\x03\x00\x00\x20\xE6\x10\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00",
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
@@ -141,11 +151,11 @@ class ActiveRecordSpatialTestCase < ActiveRecord::TestCase
     "\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00",
     "\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00",
     "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-  ].join
+  ].join.freeze
 
-  POLYGON_WITH_INTERIOR_RING = "POLYGON((0 0, 5 0, 5 5, 0 5, 0 0),(4 4, 4 1, 1 1, 1 4, 4 4))"
+  POLYGON_WITH_INTERIOR_RING = 'POLYGON((0 0, 5 0, 5 5, 0 5, 0 0),(4 4, 4 1, 1 1, 1 4, 4 4))'.freeze
 
-  LINESTRING_WKT = "LINESTRING (0 0, 5 5, 5 10, 10 10)"
+  LINESTRING_WKT = 'LINESTRING (0 0, 5 5, 5 10, 10 10)'.freeze
 
   GEOMETRYCOLLECTION_WKT = 'GEOMETRYCOLLECTION (
     MULTIPOLYGON (
@@ -161,20 +171,23 @@ class ActiveRecordSpatialTestCase < ActiveRecord::TestCase
     LINESTRING (0 0, 2 3),
     MULTIPOINT ((0 0), (2 3)),
     POINT (9 0)
-  )'
+  )'.freeze
 
-  BOUNDS_G_LAT_LNG = "((0.1, 0.1), (5.2, 5.2))"
-  BOUNDS_G_LAT_LNG_URL_VALUE = '0.1,0.1,5.2,5.2'
+  BOUNDS_G_LAT_LNG = '((0.1, 0.1), (5.2, 5.2))'.freeze
+  BOUNDS_G_LAT_LNG_URL_VALUE = '0.1,0.1,5.2,5.2'.freeze
 
   class << self
     def load_models(*args)
-      options = args.extract_options!
+      self.fixture_table_names = args.collect do |arg|
+        arg.to_s.pluralize
+      end
 
       args.each do |model|
         model = model.to_s
         klass = model.classify
+        fixtures model.tableize
 
-        ActiveSupport::Dependencies.load_file(BASE_PATH.join("models/#{model}.rb"), [ klass ])
+        ActiveSupport::Dependencies.load_file(BASE_PATH.join("models/#{model}.rb"), [klass])
       end
     end
 
@@ -195,12 +208,16 @@ class ActiveRecordSpatialTestCase < ActiveRecord::TestCase
     def after_suite
       ActiveSupport::Dependencies.clear
     end
+
+    def table_exists?(table)
+      ARBC.data_source_exists?(table)
+    end
   end
 
   def setup
-    if ActiveRecord::Base.logger
-      ActiveRecord::Base.logger.debug("Beginning tests for #{self.class.name}##{self.method_name}")
-    end
+    return unless ActiveRecord::Base.logger
+
+    ActiveRecord::Base.logger.debug("Beginning tests for #{self.class.name}##{method_name}")
   end
 
   def assert_saneness_of_point(point)
@@ -213,49 +230,20 @@ class ActiveRecordSpatialTestCase < ActiveRecord::TestCase
     assert_kind_of(Geos::Polygon, polygon)
     cs = polygon.exterior_ring.coord_seq
     assert_equal([
-      [ 0, 0 ],
-      [ 1, 1 ],
-      [ 2.5, 2.5 ],
-      [ 5, 5 ],
-      [ 0, 0 ]
+      [0, 0],
+      [1, 1],
+      [2.5, 2.5],
+      [5, 5],
+      [0, 0]
     ], cs.to_a)
   end
-end
-
-if !defined?(ActiveRecord::SQLCounter)
-  module ActiveRecord
-    class SQLCounter
-      cattr_accessor :ignored_sql
-      self.ignored_sql = [
-        /^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/,
-        /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/,
-        /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/, /^ROLLBACK/, /\WFROM pg_/
-      ]
-
-      cattr_accessor :log
-      self.log = []
-
-      attr_reader :ignore
-
-      def initialize(ignore = self.class.ignored_sql)
-        @ignore   = ignore
-      end
-
-      def call(name, start, finish, message_id, values)
-        sql = values[:sql]
-
-        # FIXME: this seems bad. we should probably have a better way to indicate
-        # the query was cached
-        return if 'CACHE' == values[:name] || ignore.any? { |x| x =~ sql }
-        self.class.log << sql
-      end
-    end
 
-    ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+  def reflection_key(key)
+    key.to_s
   end
 end
 
-class SpatialTestRunner < MiniTest::Reporters::SpecReporter
+class SpatialTestRunner < Minitest::Reporters::SpecReporter
   def before_suite(suite)
     super(suite)
     suite.before_suite if suite.respond_to?(:before_suite)
@@ -267,5 +255,4 @@ class SpatialTestRunner < MiniTest::Reporters::SpecReporter
   end
 end
 
-MiniTest::Reporters.use!(SpatialTestRunner.new)
-
+Minitest::Reporters.use!(SpatialTestRunner.new)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-spatial
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - J Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2017-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,34 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "!="
-      - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: geos-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0.dev
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0.dev
+        version: '0.5'
 description: ActiveRecord Spatial gives AR the ability to work with PostGIS columns.
 email: dark.panda@gmail.com
 executables: []
@@ -52,6 +46,7 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - Guardfile
 - MIT-LICENSE
@@ -61,6 +56,7 @@ files:
 - lib/activerecord-spatial.rb
 - lib/activerecord-spatial/active_record.rb
 - lib/activerecord-spatial/active_record/connection_adapters/postgresql/adapter_extensions.rb
+- lib/activerecord-spatial/active_record/connection_adapters/postgresql/adapter_extensions/active_record.rb
 - lib/activerecord-spatial/active_record/connection_adapters/postgresql/postgis.rb
 - lib/activerecord-spatial/active_record/connection_adapters/postgresql/unknown_srid.rb
 - lib/activerecord-spatial/active_record/models/geography_column.rb
@@ -69,14 +65,19 @@ files:
 - lib/activerecord-spatial/active_record/models/spatial_ref_sys.rb
 - lib/activerecord-spatial/associations.rb
 - lib/activerecord-spatial/associations/active_record.rb
-- lib/activerecord-spatial/associations/active_record_3.rb
 - lib/activerecord-spatial/associations/base.rb
+- lib/activerecord-spatial/associations/preloader/spatial_association.rb
+- lib/activerecord-spatial/associations/reflection/spatial_reflection.rb
 - lib/activerecord-spatial/spatial_columns.rb
 - lib/activerecord-spatial/spatial_function.rb
 - lib/activerecord-spatial/spatial_scope_constants.rb
+- lib/activerecord-spatial/spatial_scope_constants/postgis_2_0.rb
+- lib/activerecord-spatial/spatial_scope_constants/postgis_2_2.rb
+- lib/activerecord-spatial/spatial_scope_constants/postgis_legacy.rb
 - lib/activerecord-spatial/spatial_scopes.rb
 - lib/activerecord-spatial/version.rb
 - lib/tasks/test.rake
+- test/.rubocop.yml
 - test/accessors_geographies_tests.rb
 - test/accessors_geometries_tests.rb
 - test/adapter_tests.rb
@@ -120,11 +121,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: ActiveRecord Spatial gives AR the ability to work with PostGIS columns.
 test_files:
+- test/.rubocop.yml
 - test/accessors_geographies_tests.rb
 - test/accessors_geometries_tests.rb
 - test/adapter_tests.rb

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

@@ -1,123 +0,0 @@
-
-module ActiveRecord
-  module Associations
-    class Builder::Spatial < Builder::HasMany #:nodoc:
-      self.macro = SPATIAL_MACRO
-      self.valid_options += VALID_SPATIAL_OPTIONS
-      self.valid_options -= INVALID_SPATIAL_OPTIONS
-    end
-
-    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
-
-          scoped.
-            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])
-        end
-      end
-    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
-
-          conditions = self.conditions[i]
-          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
-            )
-          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
-
-            conditions.each do |condition|
-              scope = scope.where(interpolate(condition))
-            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)
-            end
-
-            scope = scope.joins(join(foreign_table, constraint))
-
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
-            end
-          end
-        end
-
-        scope
-      end
-      alias_method_chain :add_constraints, :spatial
-    end
-  end
-end
-
-module ActiveRecordSpatial::Associations
-  module ClassMethods #:nodoc:
-    def has_many_spatially(name, options = {}, &extension)
-      options = build_options(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
-
-      ActiveRecord::Associations::Builder::Spatial.build(self, name, options, &extension)
-    end
-  end
-end
-