spatial_features 2.17.3 → 2.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0a8fb7f4886f07f02b8b110f7975d91538324d6cf2c5a70b3b247dfb6719c98
-  data.tar.gz: 15c681c5de6fccb10a515c8ff1f8a423a7c9fa1c1fded8955c2072dd76f5d4f2
+  metadata.gz: 639dee46fedd2cf507642b41119ff99e93506b54d891ab42d21a1f24fcf5a679
+  data.tar.gz: 956175227c6a59acc867810a51796303218eac70c9bc49fe0d0f8222ea8558e6
 SHA512:
-  metadata.gz: 0a9224909db6dd85bf20cf9b9561e78cdc12f094423c86b0280f0e2a96e2dad9ae24030c4a4014b448f566e232b7dd37620d2a8890c411af97487a0047261346
-  data.tar.gz: 740174a0882bc82edd053e4adf31318c6afc51860a66a3d50068e3c106cc8ac9351061f9d4990c652c5f41704815e2d5b8c8ef3d6b7aaa47525d9663f01acce4
+  metadata.gz: 6a1ac7a0dca15400e0e03f0f1c2192e22a4c1e818edde2a832f925e6ee803a9284c5236684228e25dbeabf2d147aacef4f4c05170216b0857941c87ed9b9a395
+  data.tar.gz: da6fc8be7449202dfe46de18f0829e49664626ba17b90b6e3c1eae7a059f38a10d8310046e4f2bf44fb80bf78f2cdeea26624f429fc0d7b5873775b332086712

data/README.md

@@ -109,8 +109,17 @@ Person.new(:features => [Feature.new(:geog => 'some binary PostGIS Geography str
 You can specify multiple import sources for geometry. Each key is a method that returns the data for the Importer, and
 each value is the Importer to use to parse the data. See each Importer for more details.
 ```ruby
+def ImageImporter
+  def self.call(feature, image_paths)
+    image_paths.each do |pathname|
+      # ...
+    end
+  end
+end
+
 class Location < ActiveRecord::Base
-  has_spatial_features :import => { :remote_kml_url => 'KMLFile', :file => 'File', :geojson => 'GeoJSON' }
+  has_spatial_features :import => { :remote_kml_url => 'KMLFile', :file => 'File', :geojson => 'GeoJSON' },
+                       :image_handlers => ['ImageImporter']
 
   def remote_kml_url
     "www.test.com/kml/#{id}.kml"

data/app/models/abstract_feature.rb

@@ -49,8 +49,7 @@ class AbstractFeature < ActiveRecord::Base
     where(:feature_type => 'point')
   end
 
-  def self.within_distance(lat, lng, distance_in_meters)
-    # where("ST_DWithin(features.geog, ST_SetSRID( ST_Point( -71.104, 42.315), 4326)::geography, :distance)", :lat => lat, :lng => lng, :distance => distance_in_meters)
+  def self.within_distance_of_point(lat, lng, distance_in_meters)
     where("ST_DWithin(features.geog, ST_Point(:lng, :lat), :distance)", :lat => lat, :lng => lng, :distance => distance_in_meters)
   end
 
@@ -73,6 +72,10 @@ class AbstractFeature < ActiveRecord::Base
     join_other_features(other).where('ST_Intersects(features.geom_lowres, other_features.geom_lowres)').uniq
   end
 
+  def self.within_distance(other, distance_in_meters)
+    join_other_features(other).where('ST_DWithin(features.geom_lowres, other_features.geom_lowres, ?)', distance_in_meters).uniq
+  end
+
   def self.invalid(column = 'geog::geometry')
     select("features.*, ST_IsValidReason(#{column}) AS invalid_geometry_message").where.not("ST_IsValid(#{column})")
   end

data/app/models/aggregate_feature.rb

@@ -4,7 +4,11 @@ class AggregateFeature < AbstractFeature
   has_many :features, lambda { |aggregate| where(:spatial_model_type => aggregate.spatial_model_type) }, :foreign_key => :spatial_model_id, :primary_key => :spatial_model_id
 
   # Aggregate the features for the spatial model into a single feature
-  def refresh
+  before_validation :set_geog, :on => :create, :unless => :geog?
+
+  private
+
+  def set_geog
     feature_array_sql = <<~SQL
       ARRAY[
         (#{features.select('ST_UNION(ST_CollectionExtract(geog::geometry, 1))').to_sql}),
@@ -19,6 +23,5 @@ class AggregateFeature < AbstractFeature
       FROM (SELECT unnest(#{feature_array_sql})) AS features
       WHERE NOT ST_IsEmpty(unnest)
     SQL
-    self.save!
   end
 end

data/app/models/feature.rb

@@ -1,3 +1,5 @@
+require_dependency SpatialFeatures::Engine.root.join('app/models/abstract_feature')
+
 class Feature < AbstractFeature
   class_attribute :automatically_refresh_aggregate
   self.automatically_refresh_aggregate = true
@@ -13,6 +15,8 @@ class Feature < AbstractFeature
 
   after_save :refresh_aggregate, if: :automatically_refresh_aggregate?
 
+  attr_accessor :importable_image_paths # :nodoc:
+
   # Features are used for display so we also cache their KML representation
   def self.cache_derivatives(options = {})
     super
@@ -52,8 +56,8 @@ class Feature < AbstractFeature
   end
 
   def refresh_aggregate
-    build_aggregate_feature unless aggregate_feature&.persisted?
-    aggregate_feature.refresh
+    aggregate_feature&.destroy # Destroy the existing aggregate feature to ensure its cache key changes when it is refreshed
+    create_aggregate_feature!
   end
 
   def automatically_refresh_aggregate?

data/lib/spatial_features/has_spatial_features/feature_import.rb

@@ -8,7 +8,7 @@ module SpatialFeatures
     included do
       extend ActiveModel::Callbacks
       define_model_callbacks :update_features
-      spatial_features_options.reverse_merge!(:import => {}, spatial_cache: [])
+      spatial_features_options.reverse_merge!(:import => {}, :spatial_cache => [], :image_handlers => [])
     end
 
     module ClassMethods
@@ -78,13 +78,30 @@ module SpatialFeatures
       "SpatialFeatures::Importers::#{importer_name}".constantize
     end
 
+    def handle_images(feature)
+      return if feature.importable_image_paths.nil? || feature.importable_image_paths.empty?
+
+      Array(spatial_features_options[:image_handlers]).each do |image_handler|
+        image_handler_from_name(image_handler).call(feature, feature.importable_image_paths)
+      end
+    end
+
+    def image_handler_from_name(handler_name)
+      handler_name.to_s.constantize
+    end
+
     def import_features(imports, skip_invalid)
       features.delete_all
       valid, invalid = Feature.defer_aggregate_refresh do
         Feature.without_caching_derivatives do
           imports.flat_map(&:features).partition do |feature|
             feature.spatial_model = self
-            feature.save
+            if feature.save
+              handle_images(feature)
+              true
+            else
+              false
+            end
           end
         end
       end

data/lib/spatial_features/has_spatial_features/queued_spatial_processing.rb

@@ -11,7 +11,22 @@ module SpatialFeatures
     end
 
     def updating_features?
-      running_feature_update_jobs.exists?
+      case spatial_processing_status(:update_features!)
+      when :queued, :processing
+        true
+      else
+        false
+      end
+    end
+
+    def updating_features_failed?
+      spatial_processing_status(:update_features!) == :failure
+    end
+
+    def spatial_processing_status(method_name)
+      if has_attribute?(:spatial_processing_status_cache)
+        spatial_processing_status_cache[method_name.to_s]&.to_sym
+      end
     end
 
     def feature_update_error
@@ -27,17 +42,58 @@ module SpatialFeatures
     end
 
     def spatial_processing_jobs(suffix = nil)
-      Delayed::Job.where('queue LIKE ?', "#{spatial_processing_queue_name}#{suffix}%")
+      Delayed::Job.where(:queue => "#{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)
+      Delayed::Job.enqueue SpatialProcessingJob.new(self, method_name, *args), :queue => spatial_processing_queue_name + method_name
     end
 
     def spatial_processing_queue_name
-      "#{self.class}/#{self.id}/"
+      "#{model_name}/#{id}/"
+    end
+
+    # CLASSES
+
+    class SpatialProcessingJob
+      def initialize(record, method_name, *args)
+        @record = record
+        @method_name = method_name
+        @args = args
+      end
+
+      def enqueue(job)
+        update_cached_status(:queued)
+      end
+
+      def perform
+        update_cached_status(:processing)
+        @record.send(@method_name, *@args)
+      end
+
+      def success(job)
+        update_cached_status(:success)
+      end
+
+      def error(job, exception)
+        update_cached_status(:failure)
+      end
+
+      def failure(job)
+        update_cached_status(:failure)
+      end
+
+      private
+
+      def update_cached_status(state)
+        if @record.has_attribute?(:spatial_processing_status_cache)
+          cache = @record.spatial_processing_status_cache || {}
+          cache[@method_name] = state
+          @record.update_column(:spatial_processing_status_cache, cache)
+        end
+      end
     end
   end
 end

data/lib/spatial_features/importers/base.rb

@@ -46,7 +46,8 @@ module SpatialFeatures
       end
 
       def build_feature(record)
-        Feature.new(:name => record.name, :metadata => record.metadata, :feature_type => record.feature_type, :geog => record.geog, :make_valid => @make_valid)
+        importable_image_paths = record.importable_image_paths if record.respond_to?(:importable_image_paths)
+        Feature.new(:name => record.name, :metadata => record.metadata, :feature_type => record.feature_type, :geog => record.geog, :importable_image_paths => importable_image_paths, :make_valid => @make_valid)
       end
     end
   end

data/lib/spatial_features/importers/kml.rb

@@ -3,6 +3,14 @@ require 'ostruct'
 module SpatialFeatures
   module Importers
     class KML < Base
+      # <SimpleData name> keys that may contain <img> tags
+      IMAGE_METADATA_KEYS = %w[pdfmaps_photos].freeze
+
+      def initialize(data, base_dir: nil, **args)
+        @base_dir = base_dir
+        super data, **args
+      end
+
       private
 
       def each_record(&block)
@@ -18,10 +26,11 @@ module SpatialFeatures
             next if blank_feature?(feature)
 
             geog = geom_from_kml(feature)
-
             next if geog.blank?
 
-            yield OpenStruct.new(:feature_type => sql_type, :geog => geog, :name => name, :metadata => metadata)
+            importable_image_paths = images_from_metadata(metadata)
+
+            yield OpenStruct.new(:feature_type => sql_type, :geog => geog, :name => name, :metadata => metadata, :importable_image_paths => importable_image_paths)
           end
         end
       end
@@ -32,17 +41,35 @@ module SpatialFeatures
 
       def geom_from_kml(kml)
         geom = nil
+        conn = nil
 
         # Do query in a new thread so we use a new connection (if the query fails it will poison the transaction of the current connection)
+        #
+        # We manually checkout a new connection since Rails re-uses DB connections across threads.
         Thread.new do
-          geom = SpatialFeatures::Utils.select_db_value("SELECT ST_GeomFromKML(#{ActiveRecord::Base.connection.quote(kml.to_s)})")
+          conn = ActiveRecord::Base.connection_pool.checkout
+          geom = conn.select_value("SELECT ST_GeomFromKML(#{conn.quote(kml.to_s)})")
         rescue ActiveRecord::StatementInvalid => e # Discard Invalid KML features
           geom = nil
+        ensure
+          ActiveRecord::Base.connection_pool.checkin(conn) if conn
         end.join
 
         return geom
       end
 
+      def images_from_metadata(metadata)
+        IMAGE_METADATA_KEYS.flat_map do |key|
+          images = metadata.delete(key)
+          next unless images
+
+          Nokogiri::HTML.fragment(images).css("img").map do |img|
+            next unless (src = img["src"])
+            @base_dir.join(src.downcase)
+          end
+        end.compact
+      end
+
       def extract_metadata(placemark)
         metadata = {}
         metadata.merge! extract_table(placemark)

data/lib/spatial_features/importers/kml_file.rb

@@ -1,13 +1,17 @@
 module SpatialFeatures
   module Importers
     class KMLFile < KML
-      def initialize(path_or_url, *args)
-        super Download.read(path_or_url, unzip: '.kml'), *args
-
+      def initialize(path_or_url, **options)
+        path = Download.open_each(path_or_url, unzip: [/\.kml$/], downcase: true).first
+        super ::File.read(path), base_dir: Pathname.new(path).dirname, **options
       rescue SocketError, Errno::ECONNREFUSED, OpenURI::HTTPError
         url = URI(path_or_url)
         raise ImportError, "KML server is not responding. Ensure server is running and accessible at #{[url.scheme, "//#{url.host}", url.port].select(&:present?).join(':')}."
       end
+
+      def cache_key
+        @cache_key ||= Digest::MD5.hexdigest(@data)
+      end
     end
   end
 end

data/lib/spatial_features/unzip.rb

@@ -2,6 +2,9 @@ require 'fileutils'
 
 module SpatialFeatures
   module Unzip
+    # paths containing '__macosx' or beginning with a '.'
+    IGNORED_ENTRY_PATHS = /(\A|\/)(__macosx|\.)/i.freeze
+
     def self.paths(file_path, find: nil, **extract_options)
       paths = extract(file_path, **extract_options)
 
@@ -16,6 +19,7 @@ module SpatialFeatures
     def self.extract(file_path, output_dir = Dir.mktmpdir, downcase: false)
       [].tap do |paths|
         entries(file_path).each do |entry|
+          next if entry.name =~ IGNORED_ENTRY_PATHS
           output_filename = entry.name
           output_filename = output_filename.downcase if downcase
           path = "#{output_dir}/#{output_filename}"

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "2.17.3"
+  VERSION = "2.20.0"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 2.17.3
+  version: 2.20.0
 platform: ruby
 authors:
 - Ryan Wallace
 - Nicholas Jakobsen
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-04 00:00:00.000000000 Z
+date: 2021-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -87,20 +87,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: chroma
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -144,7 +130,6 @@ files:
 - app/models/feature.rb
 - app/models/spatial_cache.rb
 - app/models/spatial_proximity.rb
-- config/initializers/chroma_serializers.rb
 - config/initializers/mime_types.rb
 - config/initializers/register_oids.rb
 - lib/spatial_features.rb
@@ -175,7 +160,7 @@ homepage: https://github.com/culturecode/spatial_features
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -190,8 +175,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.0.3
+signing_key: 
 specification_version: 4
 summary: Adds spatial methods to a model.
 test_files: []

data/config/initializers/chroma_serializers.rb

@@ -1,15 +0,0 @@
-module Chroma
-  class Color
-    module Serializers
-      # Google's Fusion Table colouring expects the alpha value in the last position, not the first
-      def to_ft_hex
-        [
-         to_2char_hex(@rgb.r),
-         to_2char_hex(@rgb.g),
-         to_2char_hex(@rgb.b),
-         to_2char_hex(alpha * 255)
-        ].join('')
-      end
-    end
-  end
-end