spatial_features 2.2.4 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d84b44917dac8280a1de81c1a440d4127485846
-  data.tar.gz: fa5a503cce899bcb8d75e7c1fc3087c414b2fabd
+  metadata.gz: 7c370633815f2fd2637a8d5f8c47903b13ec623e
+  data.tar.gz: 182d9a77aca580e40aa999a2784e4bb7b02515de
 SHA512:
-  metadata.gz: a7e260e34f722ab7b668bcd9b92830d4e8d720e8159f1ac488c61091a57f78842cef8579ae5cb47973f328f46276fdf29e59d131a1b66ffe74069e52f791ac92
-  data.tar.gz: bd354f3f27912b24c8aa2f4cd92ad1e3dd2d29815217e1aca1ab77b5977ea6be196470e36c2066abd67caf90322954cf7df1c232aa0ff02e567e42e8089ff30d
+  metadata.gz: c38c86a9daeb07fd1b0eb308e02941d29d67a14e8e62cd7cbc4833887f5a5f5fc6557923f60eec19566a84d9c0a9b7d38f014693d8e4a458c62dfd2765efbe01
+  data.tar.gz: 14ff222d08e0114323b97501855feed7790187cd2990a06466a631e54212e138d33927769942f7e657f35bf58048a11596e4b57d02feadbe9afe3db740c1ee13

data/app/models/spatial_cache.rb

@@ -1,6 +1,11 @@
 class SpatialCache < ActiveRecord::Base
   belongs_to :spatial_model, :polymorphic => true, :inverse_of => :spatial_cache
 
+  def self.between(spatial_model, klass)
+    where(SpatialFeatures::Utils.polymorphic_condition(spatial_model, 'spatial_model'))
+    .where(SpatialFeatures::Utils.polymorphic_condition(klass, 'intersection_model'))
+  end
+
   def stale?
     spatial_model.has_spatial_features_hash? && self.features_hash != spatial_model.features_hash
   end

data/app/models/spatial_proximity.rb

@@ -1,4 +1,11 @@
 class SpatialProximity < ActiveRecord::Base
   belongs_to :model_a, :polymorphic => true
   belongs_to :model_b, :polymorphic => true
+
+  def self.between(scope_1, scope_2)
+    where <<-SQL.squish
+      (#{SpatialFeatures::Utils.polymorphic_condition(scope_1, 'model_a')} AND #{SpatialFeatures::Utils.polymorphic_condition(scope_2, 'model_b')}) OR
+      (#{SpatialFeatures::Utils.polymorphic_condition(scope_2, 'model_a')} AND #{SpatialFeatures::Utils.polymorphic_condition(scope_1, 'model_b')})
+    SQL
+  end
 end

data/lib/spatial_features/caching.rb

@@ -53,17 +53,14 @@ module SpatialFeatures
       SpatialCache.delete_all
       SpatialProximity.delete_all
     else
-      SpatialCache.where(:spatial_model_type => klass, :intersection_model_type => clazz).delete_all
-      SpatialCache.where(:spatial_model_type => clazz, :intersection_model_type => klass).delete_all
-      SpatialProximity.where(:model_a_type => klass, :model_b_type => clazz).delete_all
-      SpatialProximity.where(:model_a_type => clazz, :model_b_type => klass).delete_all
+      SpatialCache.between(klass, clazz).delete_all
+      SpatialProximity.between(klass, clazz).delete_all
     end
   end
 
   def self.clear_record_cache(record, klass)
     record.spatial_cache.where(:intersection_model_type => klass).delete_all
-    SpatialProximity.where(:model_a_type => record.class, :model_a_id => record.id, :model_b_type => klass).delete_all
-    SpatialProximity.where(:model_b_type => record.class, :model_b_id => record.id, :model_a_type => klass).delete_all
+    SpatialProximity.between(record, klass).delete_all
   end
 
   def self.create_spatial_proximities(record, klass)

data/lib/spatial_features/controller_helpers/spatial_extensions.rb

@@ -1,10 +1,10 @@
 module SpatialExtensions
   private
 
-  def abstract_refresh_geometry_action(models, cache_classes)
+  def abstract_refresh_geometry_action(models)
     Array.wrap(models).each do |model|
       model.failed_feature_update_jobs.destroy_all
-      model.queue_feature_update!(:cache_classes => cache_classes)
+      model.delay_update_features!
     end
 
     redirect_to :back

data/lib/spatial_features/has_spatial_features/feature_import.rb

@@ -3,14 +3,23 @@ require 'digest/md5'
 module SpatialFeatures
   module FeatureImport
     extend ActiveSupport::Concern
+    include QueuedSpatialProcessing
 
     included do
       extend ActiveModel::Callbacks
       define_model_callbacks :update_features
-      spatial_features_options.reverse_merge!(:import => {})
+      spatial_features_options.reverse_merge!(:import => {}, spatial_cache: [])
     end
 
-    def update_features!(skip_invalid: false, options: {})
+    module ClassMethods
+      def update_features!(skip_invalid: false)
+        find_each do |record|
+          record.update_features!(skip_invalid: skip_invalid)
+        end
+      end
+    end
+
+    def update_features!(skip_invalid: false, **options)
       options = options.reverse_merge(spatial_features_options)
 
       ActiveRecord::Base.transaction do
@@ -21,13 +30,40 @@ module SpatialFeatures
 
         run_callbacks :update_features do
           import_features(imports, skip_invalid)
-          set_features_cache_key(cache_key)
+          update_features_cache_key(cache_key)
+          update_features_area
+
+          if options[:spatial_cache].present? && options[:queue_spatial_cache]
+            queue_update_spatial_cache(options.slice(:spatial_cache))
+          else
+            update_spatial_cache(options.slice(:spatial_cache))
+          end
         end
 
         return true
       end
     end
 
+    def update_features_cache_key(cache_key)
+      return unless has_spatial_features_hash?
+      self.features_hash = cache_key
+      update_column(:features_hash, features_hash) unless new_record?
+    end
+
+    def update_features_area
+      return unless has_spatial_features_hash?
+      self.features_area = features.area(:cache => false)
+      update_column :features_area, features_area unless new_record?
+    end
+
+    def update_spatial_cache(options = {})
+      options = options.reverse_merge(spatial_features_options)
+
+      Array.wrap(options[:spatial_cache]).select(&:present?).each do |klass|
+        SpatialFeatures.cache_record_proximity(self, klass.to_s.constantize)
+      end
+    end
+
     private
 
     def spatial_feature_imports(import_options, make_valid)
@@ -48,12 +84,14 @@ module SpatialFeatures
         feature.save
       end
 
-      if !skip_invalid && invalid.present?
-        errors = imports.flat_map(&:errors)
-        invalid.each do |feature|
-          errors << "Feature #{feature.name}: #{feature.errors.full_messages.to_sentence}"
-        end
+      errors = imports.flat_map(&:errors)
+      invalid.each do |feature|
+        errors << "Feature #{feature.name}: #{feature.errors.full_messages.to_sentence}"
+      end
 
+      if skip_invalid && errors.present?
+        Rails.logger.warn "Error updating #{self.class} #{self.id}. #{errors.to_sentence}"
+      elsif errors.present?
         raise ImportError, "Error updating #{self.class} #{self.id}. #{errors.to_sentence}"
       end
 
@@ -63,12 +101,6 @@ module SpatialFeatures
     def features_cache_key_matches?(cache_key)
       has_spatial_features_hash? && cache_key == features_hash
     end
-
-    def set_features_cache_key(cache_key)
-      return unless has_spatial_features_hash?
-      self.features_hash = cache_key
-      update_column(:features_hash, cache_key) unless new_record?
-    end
   end
 
   class ImportError < StandardError; end

data/lib/spatial_features/has_spatial_features/queued_spatial_processing.rb

@@ -0,0 +1,43 @@
+module SpatialFeatures
+  module QueuedSpatialProcessing
+    extend ActiveSupport::Concern
+
+    def queue_update_spatial_cache(*args)
+      queue_spatial_task('update_spatial_cache', *args)
+    end
+
+    def delay_update_features!(*args)
+      queue_spatial_task('update_features!', *args)
+    end
+
+    def updating_features?
+      running_feature_update_jobs.exists?
+    end
+
+    def feature_update_error
+      (failed_feature_update_jobs.first.try(:last_error) || '').split("\n").first
+    end
+
+    def running_feature_update_jobs
+      spatial_processing_jobs('update_features!').where(failed_at: nil)
+    end
+
+    def failed_feature_update_jobs
+      spatial_processing_jobs('update_features!').where.not(failed_at: nil)
+    end
+
+    def spatial_processing_jobs(suffix = nil)
+      Delayed::Job.where('queue LIKE ?', "#{spatial_processing_queue_name}#{suffix}%")
+    end
+
+    private
+
+    def queue_spatial_task(method_name, *args)
+      delay(:queue => spatial_processing_queue_name + method_name).send(method_name, *args)
+    end
+
+    def spatial_processing_queue_name
+      "#{self.class}/#{self.id}/"
+    end
+  end
+end

data/lib/spatial_features/has_spatial_features.rb

@@ -7,7 +7,7 @@ module SpatialFeatures
 
         extend ClassMethods
         include InstanceMethods
-        include DelayedFeatureImport
+        include FeatureImport
 
         has_many :features, lambda { extending FeaturesAssociationExtensions }, :as => :spatial_model, :dependent => :delete_all
 
@@ -22,8 +22,6 @@ module SpatialFeatures
         has_many :model_a_spatial_proximities, :as => :model_a, :class_name => 'SpatialProximity', :dependent => :delete_all
         has_many :model_b_spatial_proximities, :as => :model_b, :class_name => 'SpatialProximity', :dependent => :delete_all
 
-        after_save :update_features_area, :if => :features_hash_changed? if has_features_area? && has_spatial_features_hash?
-
         delegate :has_spatial_features_hash?, :has_features_area?, :to => self
       end
 
@@ -100,7 +98,7 @@ module SpatialFeatures
       options = options.reverse_merge(:columns => "#{table_name}.*")
 
       # Don't use the cache if it doesn't exist
-      return all.extending(UncachedRelation) unless other.spatial_cache_for?(class_for(self), buffer_in_meters)
+      return all.extending(UncachedRelation) unless other.spatial_cache_for?(Utils.class_of(self), buffer_in_meters)
 
       scope = cached_spatial_join(other)
       scope = scope.select(options[:columns])
@@ -111,14 +109,14 @@ module SpatialFeatures
     end
 
     def cached_spatial_join(other)
-      other_class = class_for(other)
+      other_class = Utils.class_of(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)})")
+      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 (#{Utils.id_sql(other)})")
     end
 
     def uncached_within_buffer_scope(other, buffer_in_meters, options)
@@ -153,30 +151,10 @@ module SpatialFeatures
 
     def features_scope(other)
       scope = Feature
-      scope = scope.where(:spatial_model_type => class_for(other))
-      scope = scope.where(:spatial_model_id => other) unless class_for(other) == other
+      scope = scope.where(:spatial_model_type => Utils.class_of(other))
+      scope = scope.where(:spatial_model_id => other) unless Utils.class_of(other) == other
       return scope
     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)
-      if other.is_a?(ActiveRecord::Base)
-        other.id || '0'
-      else
-        other.unscope(:select).select(:id).to_sql
-      end
-    end
   end
 
   module InstanceMethods
@@ -221,11 +199,12 @@ module SpatialFeatures
 
     def total_intersection_area_in_square_meters(other)
       other = other.intersecting(self) unless other.is_a?(ActiveRecord::Base)
+      return features.area if spatial_cache_for?(other, 0) && SpatialProximity.between(self, other).where('intersection_area_in_square_meters >= ?', features.area).exists?
       return features.total_intersection_area_in_square_meters(other.features)
     end
 
-    def spatial_cache_for?(klass, buffer_in_meters)
-      if cache = spatial_cache_for(klass)
+    def spatial_cache_for?(other, buffer_in_meters)
+      if cache = spatial_cache.between(self, SpatialFeatures::Utils.class_of(other)).first
         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
@@ -235,14 +214,6 @@ module SpatialFeatures
         return false
       end
     end
-
-    def spatial_cache_for(klass)
-      spatial_cache.where(:intersection_model_type => klass).first
-    end
-
-    def update_features_area
-      update_column :features_area, features.area(:cache => false)
-    end
   end
 
   module FeaturesAssociationExtensions
@@ -250,7 +221,7 @@ module SpatialFeatures
       if options[:cache] == false || !proxy_association.owner.class.has_features_area?
         area_in_square_meters
       else
-        proxy_association.owner.features_area.to_f
+        (proxy_association.owner.features_area || area_in_square_meters).to_f
       end
     end
   end

data/lib/spatial_features/utils.rb

@@ -0,0 +1,32 @@
+module SpatialFeatures
+  module Utils
+    extend self
+
+    def polymorphic_condition(scope, column_name)
+      sql = "#{column_name}_type = ?"
+      sql << " AND #{column_name}_id IN (#{id_sql(scope)})" unless scope.is_a?(Class)
+
+      return class_of(scope).send :sanitize_sql, [sql, class_of(scope)]
+    end
+
+    # Returns the class for the given, class, scope, or record
+    def class_of(object)
+      case object
+      when ActiveRecord::Base
+        object.class
+      when ActiveRecord::Relation
+        object.klass
+      else
+        object
+      end
+    end
+
+    def id_sql(object)
+      if object.is_a?(ActiveRecord::Base)
+        object.id || '0'
+      else
+        object.unscope(:select).select(:id).to_sql
+      end
+    end
+  end
+end

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "2.2.4"
+  VERSION = "2.3.0"
 end

data/lib/spatial_features.rb

@@ -1,4 +1,5 @@
 # Gems
+require 'delayed_job_active_record'
 require 'rgeo/shapefile'
 require 'nokogiri'
 require 'zip'
@@ -12,10 +13,11 @@ require 'spatial_features/venn_polygons'
 require 'spatial_features/controller_helpers/spatial_extensions'
 require 'spatial_features/download'
 require 'spatial_features/unzip'
+require 'spatial_features/utils'
 
 require 'spatial_features/has_spatial_features'
+require 'spatial_features/has_spatial_features/queued_spatial_processing'
 require 'spatial_features/has_spatial_features/feature_import'
-require 'spatial_features/has_spatial_features/delayed_feature_import'
 
 require 'spatial_features/has_fusion_table_features'
 require 'spatial_features/has_fusion_table_features/api'
@@ -30,8 +32,6 @@ require 'spatial_features/importers/kml_file_arcgis'
 require 'spatial_features/importers/geomark'
 require 'spatial_features/importers/shapefile'
 
-require 'spatial_features/workers/update_features_job'
-
 require 'spatial_features/engine'
 
 module SpatialFeatures

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 2.2.4
+  version: 2.3.0
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-08 00:00:00.000000000 Z
+date: 2016-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -161,8 +161,8 @@ files:
 - lib/spatial_features/has_fusion_table_features/configuration.rb
 - lib/spatial_features/has_fusion_table_features/service.rb
 - lib/spatial_features/has_spatial_features.rb
-- lib/spatial_features/has_spatial_features/delayed_feature_import.rb
 - lib/spatial_features/has_spatial_features/feature_import.rb
+- lib/spatial_features/has_spatial_features/queued_spatial_processing.rb
 - lib/spatial_features/importers/base.rb
 - lib/spatial_features/importers/file.rb
 - lib/spatial_features/importers/geomark.rb
@@ -171,9 +171,9 @@ files:
 - lib/spatial_features/importers/kml_file_arcgis.rb
 - lib/spatial_features/importers/shapefile.rb
 - lib/spatial_features/unzip.rb
+- lib/spatial_features/utils.rb
 - lib/spatial_features/venn_polygons.rb
 - lib/spatial_features/version.rb
-- lib/spatial_features/workers/update_features_job.rb
 - lib/tasks/spatial_features_tasks.rake
 homepage: https://github.com/culturecode/spatial_features
 licenses:

data/lib/spatial_features/has_spatial_features/delayed_feature_import.rb

@@ -1,37 +0,0 @@
-module SpatialFeatures
-  module DelayedFeatureImport
-    extend ActiveSupport::Concern
-    include FeatureImport
-
-    def queue_feature_update!(options = {})
-      job = UpdateFeaturesJob.new(options.merge :spatial_model_type => self.class, :spatial_model_id => self.id)
-      Delayed::Job.enqueue(job, :queue => delayed_jobs_queue_name)
-    end
-
-    def updating_features?
-      running_feature_update_jobs.exists?
-    end
-
-    def feature_update_error
-      (failed_feature_update_jobs.first.try(:last_error) || '').split("\n").first
-    end
-
-    def running_feature_update_jobs
-      feature_update_jobs.where(failed_at: nil)
-    end
-
-    def failed_feature_update_jobs
-      feature_update_jobs.where.not(failed_at: nil)
-    end
-
-    def feature_update_jobs
-      Delayed::Job.where(queue: delayed_jobs_queue_name)
-    end
-
-    private
-
-    def delayed_jobs_queue_name
-      "#{self.class}/#{self.id}/update_features"
-    end
-  end
-end

data/lib/spatial_features/workers/update_features_job.rb

@@ -1,51 +0,0 @@
-class UpdateFeaturesJob < Struct.new(:options)
-  def perform
-    model = options[:spatial_model_type].find(options[:spatial_model_id])
-
-    if model.update_features!
-      Array(options[:cache_classes]).each {|klass| SpatialFeatures.cache_record_proximity(model, klass) }
-      after_feature_update(model)
-    end
-  rescue => e
-    raise "Can't refresh geometry: #{normalize_message(e.message)}"
-  end
-
-  private
-
-  def after_feature_update(model)
-    # stub to be overridden
-  end
-
-  NUMBER_REGEX = /-?\d+\.\d+/
-
-  def normalize_message(message)
-    normalized_messages = []
-
-    if message =~ /invalid KML representation/
-      normalized_messages += invalid_kml_reason(message).presence || ["KML importer received invalid geometry."]
-    end
-
-    if message =~ /Self-intersection/
-      normalized_messages += message.scan(/\[(#{NUMBER_REGEX}) (#{NUMBER_REGEX})\]/).collect do |lng, lat|
-        "Self-intersection at #{lng},#{lat}"
-      end
-    end
-
-    if normalized_messages.many?
-      return '<ul><li>' + normalized_messages.join('</li><li>') + '</li></ul>'
-    elsif normalized_messages.present?
-      normalized_messages.first
-    else
-      return message
-    end
-  end
-
-  COORDINATE_REGEX = /<LinearRing><coordinates>\s*((?:#{NUMBER_REGEX},#{NUMBER_REGEX},#{NUMBER_REGEX}\s*)+)<\/coordinates><\/LinearRing>/
-  def invalid_kml_reason(message)
-    message.scan(COORDINATE_REGEX).collect do |match|
-      coords = match[0].remove(/,0\.0+/).split(/\s+/).chunk {|c| c }.map(&:first)
-
-      "Sliver polygon detected at #{coords.first}" if coords.length < 4
-    end.compact
-  end
-end