spatial_features 1.3.10 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a4f197e3ba07d1cc425b2b8b8367603c1434643
-  data.tar.gz: 3b6ad7bbd92da3ba7d2b781305463807181a8eb5
+  metadata.gz: 4825ec1877a47df3ef4c5ccb0d83ee648e093322
+  data.tar.gz: a9aa87b0eed16d9e1a12a629ece02ec164365b2c
 SHA512:
-  metadata.gz: d03677e9c02f0d812740eab6e283a83a8b64f83a39d179199149a375dc5c6f6920c1ce63754b75c1f1975fbfee592553946585994bc77cc480c62e9067cfad54
-  data.tar.gz: 5eb03110f86a432f45dea48fad7fdb4fdfd155178fc0e0f255a666b291830f732ba6ba02b6c7296761de13e84140ff38a093d1cd0458a2a92b5b11727b0aeefa
+  metadata.gz: c5b3b9952c83e2010e6138be8784b87047c11a8694a7ecf4178617415d253bbf39978ebd985b079e9dacc3bacedcb312e70467314f31bd12af27f18606c9bf0a
+  data.tar.gz: 88244ebe9df2c9d123de36aac02f9fe23cbebe946918fea36ac74c51f90bb74b7f044511ff5034aefb29851b158aa6392ffb765b41536ca66c3d1807efe61fb3

data/lib/spatial_features/has_spatial_features.rb

@@ -15,70 +15,117 @@ module SpatialFeatures
   end
 
   module ClassMethods
-  	# Add methods to generate cache keys for a record or all records of this class
-		# NOTE: features are never updated, only deleted and created, therefore we can
-		# tell if they have changed by finding the maximum id and count instead of needing timestamps
-		def features_cache_key
-      max_id, count = Feature.where(:spatial_model_type => self).pluck("MAX(id), COUNT(*)").first
-		  "#{name}/#{max_id}-#{count}"
-		end
-
-		def intersecting(other, options = {})
-		  within_buffer(other, 0, options)
-		end
-
-		def within_buffer(other, buffer_in_meters = 0, options = {})
-		  raise "Can't intersect with #{other} because it does not implement has_features" unless other.has_spatial_features?
-
-		  if options[:cache] != false # CACHED
-        return all.extending(UncachedRelation) unless other.spatial_cache_for?(self, buffer_in_meters) # Don't use the cache if it doesn't exist
-
-		    scope = cached_spatial_join(other)
-		      .select("#{table_name}.*, spatial_proximities.distance_in_meters, spatial_proximities.intersection_area_in_square_meters")
-
-		    scope = scope.where("spatial_proximities.distance_in_meters <= ?", buffer_in_meters) if buffer_in_meters
-		  else # NON-CACHED
-		    scope = joins_features_for(other)
-		      .select("#{table_name}.*")
-		      .group("#{table_name}.#{primary_key}")
-
-		    scope = scope.where('ST_DWithin(features_for.geom, features_for_other.geom, ?)', buffer_in_meters) if buffer_in_meters
-		    scope = scope.select("MIN(ST_Distance(features_for.geom, features_for_other.geom)) AS distance_in_meters") if options[:distance]
-		    scope = scope.select("SUM(ST_Area(ST_Intersection(features_for.geom, features_for_other.geom))) AS intersection_area_in_square_meters") if options[:intersection_area]
-		  end
-
-		  return scope
-		end
-
-		def polygons
-		  Feature.polygons.where(:spatial_model_type => self.class)
-		end
-
-		def lines
-		  Feature.lines.where(:spatial_model_type => self.class)
-		end
-
-		def points
-		  Feature.points.where(:spatial_model_type => self.class)
-		end
-
-		def cached_spatial_join(other)
-		  raise "Cannot use cached spatial join for the same class" if other.class.name == self.name
-
-		  other_column = other.class.name < self.name ? :model_a : :model_b
-		  self_column = other_column == :model_a ? :model_b : :model_a
-
-		  joins("INNER JOIN spatial_proximities ON spatial_proximities.#{self_column}_type = '#{self}' AND spatial_proximities.#{self_column}_id = #{table_name}.id AND spatial_proximities.#{other_column}_type = '#{other.class}' AND spatial_proximities.#{other_column}_id = '#{other.id}'")
-		end
-
-		def joins_features_for(other, table_alias = 'features_for')
-		  joins_features(table_alias)
-		  .joins(%Q(INNER JOIN features "#{table_alias}_other" ON "#{table_alias}_other".spatial_model_type = '#{other.class.name}' AND "#{table_alias}_other".spatial_model_id = #{other.id}))
-		end
-
-		def joins_features(table_alias = 'features_for')
-		  joins(%Q(INNER JOIN features "#{table_alias}" ON "#{table_alias}".spatial_model_type = '#{name}' AND "#{table_alias}".spatial_model_id = #{table_name}.id))
-		end
+    # Add methods to generate cache keys for a record or all records of this class
+    # NOTE: features are never updated, only deleted and created, therefore we can
+    # tell if they have changed by finding the maximum id and count instead of needing timestamps
+    def features_cache_key
+      max_id, count = features.pluck("MAX(id), COUNT(*)").first
+      "#{name}/#{max_id}-#{count}"
+    end
+
+    def intersecting(other, options = {})
+      within_buffer(other, 0, options)
+    end
+
+    def within_buffer(other, buffer_in_meters = 0, options = {})
+      if options[:cache] != false # CACHED
+        return all.extending(UncachedRelation) unless class_for(other).spatial_cache_for?(self, buffer_in_meters) # Don't use the cache if it doesn't exist
+
+        scope = cached_spatial_join(other)
+          .select("#{table_name}.*, spatial_proximities.distance_in_meters, spatial_proximities.intersection_area_in_square_meters")
+          .group("#{table_name}.#{primary_key}")
+
+        scope = scope.where("spatial_proximities.distance_in_meters <= ?", buffer_in_meters) if buffer_in_meters
+      else # NON-CACHED
+        scope = joins_features_for(other)
+          .select("#{table_name}.*")
+          .group("#{table_name}.#{primary_key}")
+
+        scope = scope.where('ST_DWithin(features_for.geom, features_for_other.geom, ?)', buffer_in_meters) if buffer_in_meters
+        scope = scope.select("MIN(ST_Distance(features_for.geom, features_for_other.geom)) AS distance_in_meters") if options[:distance]
+        scope = scope.select("SUM(ST_Area(ST_Intersection(features_for.geom, features_for_other.geom))) AS intersection_area_in_square_meters") if options[:intersection_area]
+      end
+
+      return scope
+    end
+
+    def covering(other)
+      scope = joins_features_for(other).select("#{table_name}.*").group("#{table_name}.#{primary_key}")
+      scope = scope.where('ST_Covers(features_for.geom, features_for_other.geom)')
+
+      return scope
+    end
+
+    def polygons
+      features.polygons
+    end
+
+    def lines
+      features.lines
+    end
+
+    def points
+      features.points
+    end
+
+    def spatial_cache_for?(other, buffer_in_meters)
+      if cache = spatial_cache_for(other)
+        return cache.intersection_cache_distance.nil? if buffer_in_meters.nil? # cache must be total if no buffer_in_meters
+        return false if cache.stale? # cache must be for current features
+        return true if cache.intersection_cache_distance.nil? # always good if cache is total
+
+        return buffer_in_meters <= cache.intersection_cache_distance
+      else
+        return false
+      end
+    end
+
+
+    def features
+      Feature.where(:spatial_model_type => self, :spatial_model_id => all)
+    end
+
+    def joins_features_for(other, table_alias = 'features_for')
+      joins_features(table_alias)
+        .joins(%Q(INNER JOIN features "#{table_alias}_other" ON "#{table_alias}_other".spatial_model_type = '#{class_for(other)}' AND "#{table_alias}_other".spatial_model_id IN (#{ids_sql_for(other)})))
+    end
+
+    def joins_features(table_alias = 'features_for')
+      joins(%Q(INNER JOIN features "#{table_alias}" ON "#{table_alias}".spatial_model_type = '#{name}' AND "#{table_alias}".spatial_model_id = #{table_name}.id))
+    end
+
+    private
+
+    def cached_spatial_join(other)
+      other_class = class_for(other)
+
+      raise "Cannot use cached spatial join for the same class" if self == other_class
+
+      other_column = other_class.name < self.name ? :model_a : :model_b
+      self_column = other_column == :model_a ? :model_b : :model_a
+
+      joins("INNER JOIN spatial_proximities ON spatial_proximities.#{self_column}_type = '#{self}' AND spatial_proximities.#{self_column}_id = #{table_name}.id AND spatial_proximities.#{other_column}_type = '#{other_class}' AND spatial_proximities.#{other_column}_id IN (#{ids_sql_for(other)})")
+    end
+
+    def spatial_cache_for(other)
+      SpatialCache.where(:spatial_model_type => self, :intersection_model_type => class_for(other)).first
+    end
+
+    # Returns the class for the given, class, scope, or record
+    def class_for(other)
+      case other
+      when ActiveRecord::Base
+        other.class
+      when ActiveRecord::Relation
+        other.klass
+      else
+        other
+      end
+    end
+
+    def ids_sql_for(other)
+      other.is_a?(ActiveRecord::Base) ? other.id : other.unscope(:select).select(:id).to_sql
+    end
   end
 
   module InstanceMethods
@@ -88,78 +135,65 @@ module SpatialFeatures
 
     def features_cache_key
       max_id, count = features.pluck("MAX(id), COUNT(*)").first
-		  "#{self.class.name}/#{self.id}-#{max_id}-#{count}"
-		end
-
-		def polygons?
-		  !features.polygons.empty?
-		end
-
-		def lines?
-		  !features.lines.empty?
-		end
-
-		def points?
-		  !features.points.empty?
-		end
-
-		def features?
-		  features.present?
-		end
-
-		# Returns true if the model stores a hash of the features so we don't need to process the features if they haven't changed
-		def has_spatial_features_hash?
-		  respond_to?(:features_hash)
-		end
-
-		def intersects?(other)
-		  self.class.intersecting(other).exists?(self)
-		end
-
-		def total_intersection_area_in_square_meters(klass, options = {})
-		  self.class
-		    .select(%Q(ST_Area(ST_Intersection(ST_Union(features_for.geog_lowres::geometry), ST_Union(features_for_other.geog_lowres::geometry))::geography) AS intersection_area_in_square_meters))
-		    .joins(%Q(INNER JOIN features "features_for" ON "features_for".spatial_model_type = '#{self.class}' AND "features_for".spatial_model_id = #{self.class.table_name}.id))
-		    .joins(%Q(INNER JOIN features "features_for_other" ON "features_for_other".spatial_model_type = '#{klass}'))
-		    .where(:id => self.id)
-		    .where('ST_DWithin(features_for.geog_lowres, features_for_other.geog_lowres, 0)')
-		    .group("#{self.class.table_name}.id")
-		    .first
-		    .try(:intersection_area_in_square_meters) || 0
-		end
-
-		def total_intersection_area_in_hectares(klass)
-		  Formatters::HECTARES.call(total_intersection_area_in_square_meters(klass))
-		end
-
-		def total_intersection_area_percentage(klass)
-		  return 0.0 unless features_area_in_square_meters > 0
-
-		  ((total_intersection_area_in_square_meters(klass) / features_area_in_square_meters) * 100).round(1)
-		end
-
-		def features_area_in_square_meters
-		  @features_area_in_square_meters ||= features.sum('features.area')
-		end
-
-		def features_area_in_hectares
-		  Formatters::HECTARES.call(features_area_in_square_meters)
-		end
-
-		def spatial_cache_for(klass)
-		  spatial_cache.where(:intersection_model_type => klass).first
-		end
-
-		def spatial_cache_for?(klass, buffer_in_meters)
-		  if cache = spatial_cache_for(klass)
-		    return cache.intersection_cache_distance.nil? if buffer_in_meters.nil? # cache must be total if no buffer_in_meters
-        return false if cache.stale? # cache must be for current features
-		    return true if cache.intersection_cache_distance.nil? # always good if cache is total
+      "#{self.class.name}/#{self.id}-#{max_id}-#{count}"
+    end
+
+    def polygons?
+      !features.polygons.empty?
+    end
+
+    def lines?
+      !features.lines.empty?
+    end
+
+    def points?
+      !features.points.empty?
+    end
+
+    def features?
+      features.present?
+    end
+
+    # Returns true if the model stores a hash of the features so we don't need to process the features if they haven't changed
+    def has_spatial_features_hash?
+      respond_to?(:features_hash)
+    end
+
+    def covers?(other)
+      self.class.covering(other).exists?(self)
+    end
+
+    def intersects?(other)
+      self.class.intersecting(other).exists?(self)
+    end
+
+    def total_intersection_area_in_square_meters(klass, options = {})
+      self.class
+        .select(%Q(ST_Area(ST_Intersection(ST_Union(features_for.geog_lowres::geometry), ST_Union(features_for_other.geog_lowres::geometry))::geography) AS intersection_area_in_square_meters))
+        .joins_features_for(klass)
+        .where(:id => self.id)
+        .where('ST_DWithin(features_for.geog_lowres, features_for_other.geog_lowres, 0)')
+        .group("#{self.class.table_name}.id")
+        .first
+        .try(:intersection_area_in_square_meters) || 0
+    end
 
-		    return buffer_in_meters <= cache.intersection_cache_distance
-		  else
-		    return false
-		  end
-		end
+    def total_intersection_area_in_hectares(klass)
+      Formatters::HECTARES.call(total_intersection_area_in_square_meters(klass))
+    end
+
+    def total_intersection_area_percentage(klass)
+      return 0.0 unless features_area_in_square_meters > 0
+
+      ((total_intersection_area_in_square_meters(klass) / features_area_in_square_meters) * 100).round(1)
+    end
+
+    def features_area_in_square_meters
+      @features_area_in_square_meters ||= features.sum('features.area')
+    end
+
+    def features_area_in_hectares
+      Formatters::HECTARES.call(features_area_in_square_meters)
+    end
   end
 end

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "1.3.10"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 1.3.10
+  version: 1.4.0
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-29 00:00:00.000000000 Z
+date: 2015-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -138,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Adds spatial methods to a model.