activerecord-spatial 0.0.1 → 0.1.0

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

@@ -0,0 +1,123 @@
+
+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
+

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

@@ -0,0 +1,182 @@
+
+module ActiveRecord
+  module Associations #:nodoc:
+    class SpatialAssociation < HasManyAssociation
+      attr_reader :geom, :foreign_geom, :relationship, :scope_options
+
+      def initialize(*args)
+        super
+
+        @geom = self.options[:geom]
+        @foreign_geom = self.options[:foreign_geom]
+        @relationship = self.options[:relationship].to_s
+        @scope_options = (self.options[:scope_options] || {}).merge({
+          :column => @foreign_geom
+        })
+      end
+    end
+
+    class Builder::Spatial < Builder::HasMany #:nodoc:
+      SPATIAL_MACRO = :has_many
+
+      VALID_SPATIAL_OPTIONS = [
+        :geom, :foreign_geom, :relationship, :scope_options
+      ].freeze
+
+      INVALID_SPATIAL_OPTIONS = [
+        :through, :source, :source_type, :dependent, :finder_sql, :counter_sql,
+        :inverse_of
+      ].freeze
+
+      private
+        def dependency_method_name
+          "spatially_#{self.relationship}_dependent_for_#{name}"
+        end
+    end
+
+    class Preloader #:nodoc:
+      class SpatialAssociation < HasMany #:nodoc:
+        SPATIAL_FIELD_ALIAS = '__spatial_ids__'
+        SPATIAL_JOIN_NAME = '__spatial_ids_join__'
+        SPATIAL_JOIN_QUOTED_NAME = %{"#{SPATIAL_JOIN_NAME}"}
+
+        private
+          def associated_records_by_owner
+            owners_map = owners_by_key
+            owner_keys = owners_map.keys.compact
+
+            if klass.nil? || owner_keys.empty?
+              records = []
+            else
+              sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
+              records = sliced.map { |slice| records_for(slice) }.flatten
+            end
+
+            records_by_owner = Hash[owners.map { |owner| [owner, []] }]
+
+            records.each do |record|
+              record[SPATIAL_FIELD_ALIAS].split(',').each do |owner_key|
+                owners_map[owner_key].each do |owner|
+                  records_by_owner[owner] << record
+                end
+              end
+            end
+
+            records_by_owner
+          end
+        end
+
+        def preloader_for_with_spatial(reflection)
+          if reflection.options[:relationship]
+            SpatialAssociation
+          else
+            preloader_for_without_spatial(reflection)
+          end
+        end
+        alias_method_chain :preloader_for, :spatial
+    end
+  end
+
+  module Reflection #:nodoc:
+    class AssociationReflection < MacroReflection #:nodoc:
+      def association_class_with_spatial
+        if self.options[:relationship]
+           Associations::SpatialAssociation
+        else
+          association_class_without_spatial
+        end
+      end
+      alias_method_chain :association_class, :spatial
+    end
+  end
+end
+
+# ActiveRecord Spatial associations allow for +has_many+-style associations
+# using spatial relationships.
+#
+# == Example
+#
+#   class Neighbourhood < ActiveRecord::Base
+#     has_many_spatially :cities,
+#       :relationship => :contains
+#   end
+#
+#   class City < ActiveRecord::Base
+#     has_many_spatially :neighbourhoods,
+#       :relationship => :within
+#   end
+#
+#   Neighbourhood.first.cities
+#   #=> All cities that the neighbourhood is within
+#
+#   City.first.neighbourhoods
+#   #=> All neighbourhoods contained by the city
+#
+#   City.includes(:neighbourhoods).first.neighbourhoods
+#   #=> Eager loading works too
+#
+# Spatial associations can be set up using any of the relationships found in
+# ActiveRecordSpatial::SpatialScopes::RELATIONSHIPS.
+#
+# == Options
+#
+# Many of the options available with standard +has_many+ associations will work
+# with the exceptions of +:through+, +:source+, +:source_type+, +:dependent+,
+# +:finder_sql+, +:counter_sql+, and +:inverse_of+.
+#
+# Polymorphic relationships can be used via the +:as+ option as in standard
+# +:has_many+ relationships. Note that the default field for the geometry
+# in these cases is "#{association_name}_geom" and can be overridden using
+# the +:foreign_geom+ option.
+#
+# * +:relationship+ - sets the spatial relationship for the association.
+#   Valid options can be found in ActiveRecordSpatial::SpatialScopes::RELATIONSHIPS.
+#   The default value is +:intersects+.
+# * +:geom+ - sets the geometry field for the association in the calling model.
+#   The default value is +:the_geom+ as is often seen in PostGIS documentation.
+# * +:foreign_geom+ - sets the geometry field for the association's foreign
+#   table. The default here is again +:the_geom+.
+# * +:scope_options+ - these are options passed directly to the SpatialScopes
+#   module and as such the options are the same as are available there. The
+#   default value here is <tt>{ :invert => true }</tt>, as we want our
+#   spatial relationships to say "Foo spatially contains many Bars" and
+#   therefore the relationship in SQL becomes
+#   <tt>ST_contains("foos"."the_geom", "bars"."the_geom")</tt>.
+#
+# Note that you can modify the default geometry column name for all of
+# ActiveRecordSpatial by setting it via ActiveRecordSpatia.default_column_name.
+#
+# == Caveats
+#
+# * You should consider spatial associations to be essentially readonly. Since
+#   we're not dealing with unique IDs here but rather 2D and 3D geometries,
+#   the relationships between rows don't really map well to the traditional
+#   foreign key-style ActiveRecord associations.
+module ActiveRecordSpatial::Associations
+  extend ActiveSupport::Concern
+
+  DEFAULT_OPTIONS = {
+    :relationship => :intersects,
+    :geom => ActiveRecordSpatial.default_column_name,
+    :foreign_geom => ActiveRecordSpatial.default_column_name,
+    :scope_options => {
+      :invert => true
+    }
+  }.freeze
+
+  module ClassMethods #:nodoc:
+    def build_options(options)
+      if !options[:foreign_geom] && options[:as]
+        options[:foreign_geom] = "#{options[:as]}_geom"
+      end
+
+      if options[:geom].is_a?(Hash)
+        options[:geom][:name] ||= ActiveRecordSpatial.default_column_name
+      end
+
+      DEFAULT_OPTIONS.deep_merge(options)
+    end
+    private :build_options
+  end
+end
+

data/lib/activerecord-spatial/spatial_columns.rb

@@ -94,7 +94,7 @@ module ActiveRecordSpatial
               if !defined?(@#{m}_columns) || @#{m}_columns.nil?
                 @#{m}_columns = ActiveRecordSpatial::#{m.capitalize}Column.where(
                   :f_table_name => self.table_name
-                ).all
+                ).to_a
                 @#{m}_columns.freeze
               end
               @#{m}_columns

data/lib/activerecord-spatial/spatial_function.rb

@@ -16,8 +16,9 @@ module ActiveRecordSpatial
 
     def build_function_call(function, *args)
       options = default_options(args.extract_options!)
-      geom = options[:geom_arg]
-      args = Array.wrap(options[:args])
+
+      geom = options.fetch(:geom_arg, args.first)
+      args = Array.wrap(options.fetch(:args, args.from(1)))
 
       column_name = self.column_name(options[:column])
       first_geom_arg = self.wrap_column_or_geometry(

data/lib/activerecord-spatial/version.rb

@@ -1,5 +1,5 @@
 
 module ActiveRecordSpatial
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end
 

data/test/associations_tests.rb

@@ -229,7 +229,7 @@ class PreloadTest < ActiveRecordSpatialTestCase
     values = nil
     assert_queries(4) do
       assert_sql(/ST_intersects\('#{REGEXP_WKB_HEX}'::geometry, "bars"\."the_geom"/) do
-        values = Foo.all.collect do |foo|
+        values = Foo.all.to_a.collect do |foo|
           foo.bars.length
         end
       end
@@ -242,7 +242,7 @@ class PreloadTest < ActiveRecordSpatialTestCase
     values = nil
     assert_queries(2) do
       assert_sql(/SELECT "bars"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "bars" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\("__spatial_ids_join__"."the_geom", "bars"."the_geom"\)\) WHERE "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "bars"\."id"/) do
-        values = Foo.includes(:bars).all.collect do |foo|
+        values = Foo.includes(:bars).to_a.collect do |foo|
           foo.bars.length
         end
       end
@@ -267,7 +267,7 @@ class PreloadWithOtherGeomTest < ActiveRecordSpatialTestCase
     values = nil
     assert_queries(4) do
       assert_sql(/ST_intersects\(ST_SetSRID\('#{REGEXP_WKB_HEX}'::geometry, #{ActiveRecordSpatial::UNKNOWN_SRID}\), "bars"\."the_geom"/) do
-        values = Foo.order('id').all.collect do |foo|
+        values = Foo.order('id').to_a.collect do |foo|
           foo.bars.length
         end
       end
@@ -280,7 +280,7 @@ class PreloadWithOtherGeomTest < ActiveRecordSpatialTestCase
     values = nil
     assert_queries(2) do
       assert_sql(/SELECT "bars"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "bars" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\(ST_SetSRID\("__spatial_ids_join__"."the_other_geom", #{ActiveRecordSpatial::UNKNOWN_SRID}\), "bars"."the_geom"\)\) WHERE "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "bars"\."id"/) do
-        values = Foo.order('id').includes(:bars).all.collect do |foo|
+        values = Foo.order('id').includes(:bars).to_a.collect do |foo|
           foo.bars.length
         end
       end
@@ -460,6 +460,8 @@ class IncludeOptionTest < ActiveRecordSpatialTestCase
   end
 
   def test_includes
+    skip("Removed from AR 4") if ActiveRecord::VERSION::MAJOR >= 4
+
     values = nil
     assert_queries(3) do
       assert_sql(/SELECT\s+"blorts"\.\*\s+FROM\s+"blorts"\s+WHERE\s+"blorts"\."foo_id"\s+IN\s+\(.+\)/) do
@@ -652,5 +654,23 @@ class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
 
     assert_equal([ 1, 2, 3 ], values)
   end
+
+  class ScopeArgumentTest < ActiveRecordSpatialTestCase
+    def setup
+      self.class.load_models(:foo, :bar, :blort)
+    end
+
+    def test_foo
+      Foo.class_eval do
+        has_many_spatially :bars, proc {
+          self.order(:id)
+        }
+      end
+
+      assert_sql(/ORDER BY "bars".id/) do
+        Foo.first.bars.to_a
+      end
+    end
+  end if ActiveRecord::VERSION::MAJOR >= 4
 end
 

data/test/spatial_function_tests.rb

@@ -0,0 +1,77 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class SpatialFunctionTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo)
+    load_models(:blort)
+  end
+
+  def test_geom_arg_option
+    assert_equal(
+      %{ST_distance("foos"."the_geom", '010100000000000000000000000000000000000000'::geometry)},
+      Foo.spatial_function(:distance, :geom_arg => 'POINT(0 0)').to_sql
+    )
+  end
+
+  def test_geom_as_argument
+    assert_equal(
+      %{ST_distance("foos"."the_geom", '010100000000000000000000000000000000000000'::geometry)},
+      Foo.spatial_function(:distance, 'POINT(0 0)').to_sql
+    )
+  end
+
+  def test_column_option
+    assert_equal(
+      %{ST_distance("foos"."the_other_geom", ST_SetSRID('010100000000000000000000000000000000000000'::geometry, 4326))},
+      Foo.spatial_function(:distance, 'POINT(0 0)', :column => 'the_other_geom').to_sql
+    )
+  end
+
+  def test_class_option
+    assert_equal(
+      %{ST_distance("foos"."the_other_geom", ST_SetSRID('010100000000000000000000000000000000000000'::geometry, 4326))},
+      Foo.spatial_function(:distance, {
+        :class => Blort,
+        :value => 'POINT(0 0)'
+      }, {
+        :column => 'the_other_geom'
+      }).to_sql
+    )
+  end
+
+  def test_class_name_option
+    assert_equal(
+      %{ST_distance("foos"."the_other_geom", ST_SetSRID('010100000000000000000000000000000000000000'::geometry, 4326))},
+      Foo.spatial_function(:distance, {
+        :class => 'Blort',
+        :value => 'POINT(0 0)'
+      }, {
+        :column => 'the_other_geom'
+      }).to_sql
+    )
+  end
+
+  def test_invert_option
+    assert_equal(
+      %{ST_distance('010100000000000000000000000000000000000000'::geometry, "foos"."the_geom")},
+      Foo.spatial_function(:distance, 'POINT(0 0)', :invert => true).to_sql
+    )
+  end
+
+  def test_use_index_option
+    assert_equal(
+      %{_ST_distance("foos"."the_geom", '010100000000000000000000000000000000000000'::geometry)},
+      Foo.spatial_function(:distance, 'POINT(0 0)', :use_index => false).to_sql
+    )
+  end
+
+  def test_allow_null_option
+    assert_equal(
+      %{(ST_distance("foos"."the_geom", '010100000000000000000000000000000000000000'::geometry) OR "foos"."the_geom" IS NULL)},
+      Foo.spatial_function(:distance, 'POINT(0 0)', :allow_null => true).to_sql
+    )
+  end
+end
+