activerecord-spatial 1.0.0 → 2.0.0

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

@@ -1,21 +1,6 @@
 
 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
 
@@ -28,65 +13,31 @@ module ActiveRecord
         :inverse_of
       ].freeze
 
-      private
-        def dependency_method_name
-          "spatially_#{self.relationship}_dependent_for_#{name}"
-        end
+      def macro
+        SPATIAL_MACRO
+      end
+
+      def self.valid_options(options)
+        super + VALID_SPATIAL_OPTIONS - INVALID_SPATIAL_OPTIONS
+      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
+        SPATIAL_FIELD_ALIAS = '__spatial_ids__'.freeze
+        SPATIAL_JOIN_NAME = '__spatial_ids_join__'.freeze
+        SPATIAL_JOIN_QUOTED_NAME = %{"#{SPATIAL_JOIN_NAME}"}.freeze
+      end
 
-        def preloader_for_with_spatial(reflection)
-          if reflection.options[:relationship]
+      prepend(Module.new do
+        def preloader_for(reflection, *args)
+          if reflection.is_a?(ActiveRecord::Reflection::SpatialReflection)
             SpatialAssociation
           else
-            preloader_for_without_spatial(reflection)
+            super
           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
 end
@@ -98,12 +49,13 @@ end
 #
 #   class Neighbourhood < ActiveRecord::Base
 #     has_many_spatially :cities,
-#       :relationship => :contains
+#       relationship: :contains
 #   end
 #
 #   class City < ActiveRecord::Base
-#     has_many_spatially :neighbourhoods,
-#       :relationship => :within
+#     has_many_spatially :neighbourhoods, -> {
+#       where('canonical = true')
+#     }, relationship: :within
 #   end
 #
 #   Neighbourhood.first.cities
@@ -138,7 +90,7 @@ end
 #   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
+#   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>.
@@ -156,11 +108,11 @@ 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
+    relationship: :intersects,
+    geom: ActiveRecordSpatial.default_column_name,
+    foreign_geom: ActiveRecordSpatial.default_column_name,
+    scope_options: {
+      invert: true
     }
   }.freeze
 
@@ -179,4 +131,3 @@ module ActiveRecordSpatial::Associations
     private :build_options
   end
 end
-

data/lib/activerecord-spatial/associations/preloader/spatial_association.rb

@@ -0,0 +1,57 @@
+
+module ActiveRecord
+  module Associations
+    class Preloader #:nodoc:
+      class SpatialAssociation < HasMany #:nodoc:
+        if method_defined?(:query_scope)
+          def query_scope(ids)
+            spatial_query_scope(ids)
+          end
+        else
+          def records_for(ids)
+            spatial_query_scope(ids)
+          end
+        end
+
+        private
+
+          def association_key_name
+            SPATIAL_FIELD_ALIAS
+          end
+
+          def spatial_query_scope(ids)
+            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
+
+            where_function = klass.send(
+              "st_#{reflection.options[:relationship]}",
+              geom,
+              (reflection.options[:scope_options] || {}).merge(
+                column: reflection.options[:foreign_geom]
+              )
+            )
+
+            scope.
+              select(%{#{klass.quoted_table_name}.*, array_to_string(array_agg(#{column}), ',') AS "#{SPATIAL_FIELD_ALIAS}"}).
+              joins(
+                "INNER JOIN #{join_name} AS #{SPATIAL_JOIN_QUOTED_NAME} ON (" <<
+                  where_function.where_clause.send(:predicates).join(' AND ') <<
+                  ')'
+              ).
+              where(model.arel_table.alias(SPATIAL_JOIN_NAME)[model.primary_key].in(ids)).
+              group(table[klass.primary_key])
+          end
+      end
+    end
+  end
+end

data/lib/activerecord-spatial/associations/reflection/spatial_reflection.rb

@@ -0,0 +1,41 @@
+
+module ActiveRecord
+  module Reflection #:nodoc:
+    SPATIAL_REFLECTION_BASE_CLASS = HasManyReflection
+
+    module RuntimeReflectionWithSpatialReflection
+      delegate :geom, :relationship, :scope_options, to: :@reflection
+    end
+
+    RuntimeReflection.prepend RuntimeReflectionWithSpatialReflection
+
+    class SpatialReflection < SPATIAL_REFLECTION_BASE_CLASS #:nodoc:
+      attr_reader :geom, :foreign_geom, :relationship, :scope_options
+
+      def initialize(*args)
+        super(*args.from(1))
+
+        @geom = options[:geom]
+        @foreign_geom = options[:foreign_geom]
+        @relationship = options[:relationship].to_s
+        @scope_options = (options[:scope_options] || {}).merge(column: foreign_geom)
+      end
+
+      def association_class
+        Associations::SpatialAssociation
+      end
+    end
+
+    class << self
+      prepend(Module.new do
+        def create(macro, name, scope, options, ar)
+          if options[:relationship] && options[:geom] && options[:foreign_geom]
+            SpatialReflection.new(macro, name, scope, options, ar)
+          else
+            super
+          end
+        end
+      end)
+    end
+  end
+end

data/lib/activerecord-spatial/associations.rb

@@ -1,10 +1,32 @@
 
 require 'activerecord-spatial/associations/base'
+require 'activerecord-spatial/associations/reflection/spatial_reflection'
+require 'activerecord-spatial/associations/preloader/spatial_association'
+require 'activerecord-spatial/associations/active_record'
 
-if ActiveRecord::VERSION::MAJOR <= 3
-  require 'activerecord-spatial/associations/active_record_3'
-else
-  require 'activerecord-spatial/associations/active_record'
+module ActiveRecordSpatial::Associations
+  module ClassMethods #:nodoc:
+    def has_many_spatially(name, scope = nil, options = {}, &extension)
+      if scope.is_a?(Hash)
+        options = scope
+        scope   = nil
+      end
+
+      options = build_options(options)
+
+      unless ActiveRecordSpatial::SpatialScopeConstants::RELATIONSHIPS.include?(options[:relationship].to_s)
+        raise ArgumentError, %{Invalid spatial relationship "#{options[:relationship]}", expected one of #{ActiveRecordSpatial::SpatialScopeConstants::RELATIONSHIPS.inspect}}
+      end
+
+      reflection = ActiveRecord::Associations::Builder::Spatial.build(self, name, scope, options, &extension)
+
+      if ActiveRecord::Reflection.respond_to?(:add_reflection)
+        ActiveRecord::Reflection.add_reflection(self, name, reflection)
+      end
+
+      reflection
+    end
+  end
 end
 
 module ActiveRecord

data/lib/activerecord-spatial/spatial_columns.rb

@@ -37,99 +37,97 @@ module ActiveRecordSpatial
     end
 
     module ClassMethods
-      protected
-        @geometry_columns = nil
-        @geography_columns = nil
-
-      public
-        # Build call to ActiveRecordSpatial::SpatialFunction.build! that helps
-        # you create spatial function calls.
-        def spatial_function(*args)
-          SpatialFunction.build!(self, *args)
-        end
+      @geometry_columns = nil
+      @geography_columns = nil
 
-        # Stubs for documentation purposes:
+      # Build call to ActiveRecordSpatial::SpatialFunction.build! that helps
+      # you create spatial function calls.
+      def spatial_function(*args)
+        SpatialFunction.build!(self, *args)
+      end
 
-        # Returns an Array of available geometry columns in the
-        # table. These are PostgreSQLColumns with values set for
-        # the srid and coord_dimensions properties.
-        def geometry_columns; end
+      # Stubs for documentation purposes:
 
-        # Returns an Array of available geography columns in the
-        # table. These are PostgreSQLColumns with values set for
-        # the srid and coord_dimensions properties.
-        def geography_columns; end
+      # Returns an Array of available geometry columns in the
+      # table. These are PostgreSQLColumns with values set for
+      # the srid and coord_dimensions properties.
+      def geometry_columns; end
 
-        # Force a reload of available geometry columns.
-        def geometry_columns!; end
+      # Returns an Array of available geography columns in the
+      # table. These are PostgreSQLColumns with values set for
+      # the srid and coord_dimensions properties.
+      def geography_columns; end
 
-        # Force a reload of available geography columns.
-        def geography_columns!; end
+      # Force a reload of available geometry columns.
+      def geometry_columns!; end
 
-        # Grabs a geometry column based on name.
-        def geometry_column_by_name(name); end
+      # Force a reload of available geography columns.
+      def geography_columns!; end
 
-        # Grabs a geography column based on name.
-        def geography_column_by_name(name); end
+      # Grabs a geometry column based on name.
+      def geometry_column_by_name(name); end
 
-        # Returns both the geometry and geography columns for a table.
-        def spatial_columns
-          self.geometry_columns + self.geography_columns
-        end
+      # Grabs a geography column based on name.
+      def geography_column_by_name(name); end
 
-        # Reloads both the geometry and geography columns for a table.
-        def spatial_columns!
-          self.geometry_columns! + self.geography_columns!
-        end
+      # Returns both the geometry and geography columns for a table.
+      def spatial_columns
+        geometry_columns + geography_columns
+      end
 
-        # Grabs a spatial column based on name.
-        def spatial_column_by_name(name)
-          self.geometry_column_by_name(name) || self.geography_column_by_name(name)
-        end
+      # Reloads both the geometry and geography columns for a table.
+      def spatial_columns!
+        geometry_columns! + geography_columns!
+      end
 
-        %w{ geometry geography }.each do |m|
-          src, line = <<-EOF, __LINE__ + 1
-            undef :#{m}_columns
-            def #{m}_columns
-              if !defined?(@#{m}_columns) || @#{m}_columns.nil?
-                @#{m}_columns = ActiveRecordSpatial::#{m.capitalize}Column.where(
-                  :f_table_name => self.table_name
-                ).to_a
-                @#{m}_columns.freeze
-              end
-              @#{m}_columns
-            end
+      # Grabs a spatial column based on name.
+      def spatial_column_by_name(name)
+        geometry_column_by_name(name) || geography_column_by_name(name)
+      end
 
-            undef :#{m}_columns!
-            def #{m}_columns!
-              @#{m}_columns = nil
-              #{m}_columns
+      %w{ geometry geography }.each do |m|
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          undef :#{m}_columns
+          def #{m}_columns
+            if !defined?(@#{m}_columns) || @#{m}_columns.nil?
+              @#{m}_columns = ActiveRecordSpatial::#{m.capitalize}Column.where(
+                f_table_name: table_name
+              ).to_a
+              @#{m}_columns.freeze
             end
+            @#{m}_columns
+          end
 
-            undef :#{m}_column_by_name
-            def #{m}_column_by_name(name)
-              @#{m}_column_by_name ||= self.#{m}_columns.inject(HashWithIndifferentAccess.new) do |memo, obj|
-                memo[obj.spatial_column] = obj
-                memo
-              end
-              @#{m}_column_by_name[name]
+          undef :#{m}_columns!
+          def #{m}_columns!
+            @#{m}_columns = nil
+            #{m}_columns
+          end
+
+          undef :#{m}_column_by_name
+          def #{m}_column_by_name(name)
+            @#{m}_column_by_name ||= #{m}_columns.inject(HashWithIndifferentAccess.new) do |memo, obj|
+              memo[obj.spatial_column] = obj
+              memo
             end
-          EOF
-          self.class_eval(src, __FILE__, line)
-        end
+            @#{m}_column_by_name[name]
+          end
+        RUBY
+      end
 
-        # Quickly grab the SRID for a geometry column.
-        def srid_for(column_name)
-          column = self.spatial_column_by_name(column_name)
-          column.try(:srid) || ActiveRecordSpatial::UNKNOWN_SRID
-        end
+      # Quickly grab the SRID for a geometry column.
+      def srid_for(column_name)
+        column = spatial_column_by_name(column_name)
+        column.try(:srid) || ActiveRecordSpatial::UNKNOWN_SRID
+      end
 
-        # Quickly grab the number of dimensions for a geometry column.
-        def coord_dimension_for(column_name)
-          self.spatial_column_by_name(column_name).coord_dimension
-        end
+      # Quickly grab the number of dimensions for a geometry column.
+      def coord_dimension_for(column_name)
+        spatial_column_by_name(column_name).coord_dimension
+      end
+
+      private
 
-      protected
         # Sets up nifty setters and getters for spatial columns.
         # The methods created look like this:
         #
@@ -152,19 +150,14 @@ module ActiveRecordSpatial
           create_these = []
 
           if options.nil?
-            create_these.concat(self.spatial_columns)
+            create_these.concat(spatial_columns)
           else
-            if options[:geometry_columns]
-              create_these.concat(self.geometry_columns)
-            end
+            create_these.concat(geometry_columns) if options[:geometry_columns]
+            create_these.concat(geography_columns) if options[:geography_columns]
 
-            if options[:geography_columns]
-              create_these.concat(self.geography_columns)
-            end
+            raise ArgumentError, "You can only specify either :except or :only (#{options.keys.inspect})" if options[:except] && options[:only]
 
-            if options[:except] && options[:only]
-              raise ArgumentError, "You can only specify either :except or :only (#{options.keys.inspect})"
-            elsif options[:except]
+            if options[:except]
               except = Array.wrap(options[:except]).collect(&:to_s)
               create_these.reject! { |c| except.include?(c) }
             elsif options[:only]
@@ -174,7 +167,7 @@ module ActiveRecordSpatial
           end
 
           create_these.each do |k|
-            src, line = <<-EOF, __LINE__ + 1
+            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
               def #{k.spatial_column}=(geom)
                 if !geom
                   self['#{k.spatial_column}'] = nil
@@ -236,16 +229,14 @@ module ActiveRecordSpatial
 
                 self['#{k.spatial_column}']
               end
-            EOF
-            self.class_eval(src, __FILE__, line)
+            RUBY
 
             SPATIAL_COLUMN_OUTPUT_FORMATS.reject { |f| f == 'geos' }.each do |f|
-              src, line = <<-EOF, __LINE__ + 1
+              class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
                 def #{k.spatial_column}_#{f}(*args)
                   @#{k.spatial_column}_#{f} ||= self.#{k.spatial_column}_geos.to_#{f}(*args) rescue nil
                 end
-              EOF
-              self.class_eval(src, __FILE__, line)
+              RUBY
             end
           end
         end
@@ -253,7 +244,7 @@ module ActiveRecordSpatial
         # Creates column accessors for geometry columns only.
         def create_geometry_column_accessors!(options = {})
           options = {
-            :geometry_columns => true
+            geometry_columns: true
           }.merge(options)
 
           create_spatial_column_accessors!(options)
@@ -262,7 +253,7 @@ module ActiveRecordSpatial
         # Creates column accessors for geometry columns only.
         def create_geography_column_accessors!(options = {})
           options = {
-            :geography_columns => true
+            geography_columns: true
           }.merge(options)
 
           create_spatial_column_accessors!(options)
@@ -323,7 +314,7 @@ module ActiveRecordSpatial
         # are equivalent:
         #
         #  spatial_column_name(:wkt)
-        #  spatial_column_name(:format => :wkt)
+        #  spatial_column_name(format: :wkt)
         #  spatial_column_name_wkt
         def __spatial_column_name(options = {}); end