spatial_features 2.12.2 → 2.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0051ead788fe05361e242dd7043efe1dee46c31260f4b3fdc782c06af5238e73
-  data.tar.gz: f9658375cee39987dd047839222781eb12b35eab73eb950e62c4349e47955dbf
+  metadata.gz: 79fb559903943c11893b5d338f5c8030971f23051cf3611a326d0e013720f5e5
+  data.tar.gz: 1311241026ec5dc76a90e04f8fcc9e93c92965875f0967e1b27a0e1f64694ab3
 SHA512:
-  metadata.gz: 2738a619531511cf2d90052a6ffdab481b5edfc875271cae30df287759ccdc09dcb1df8291c63192e5e618291410befd2d5cfcd3a3155f852a5d59c44b5b6aff
-  data.tar.gz: 114543074b9bdfea813e979505829d6282ec49524fe9ad4093b1119e7099feec2205f8b5a33b447ca8cac05470ae74b12ee93b9a7a3c6f7e66d9497ce43fa2ca
+  metadata.gz: 8080e32e08c262fb3c44c6a228b0c599a1030ec52f9daea7862a06a98aa72b46dad77fb73127d5d40e6e999549ea44ebde0b77e826b1776e92eefe6b4a14898c
+  data.tar.gz: 3d591754fdc5a1ddb92146d805074aa5dc4bc65f5261eb0c169546f886b5dee784de7f24f56829a359641ae778960ffd54923c6b2535261d2e1194e0c9db0859

data/app/models/abstract_feature.rb

@@ -1,6 +1,9 @@
 class AbstractFeature < ActiveRecord::Base
   self.table_name = 'features'
 
+  class_attribute :automatically_cache_derivatives
+  self.automatically_cache_derivatives = true
+
   class_attribute :lowres_simplification
   self.lowres_simplification = 2 # Threshold in meters
 
@@ -12,15 +15,21 @@ class AbstractFeature < ActiveRecord::Base
 
   before_validation :sanitize_feature_type
   validates_presence_of :geog
-  validate :validate_geometry
-  before_save :sanitize
-  after_save :cache_derivatives, :if => :saved_change_to_geog?
+  validate :validate_geometry, if: :will_save_change_to_geog?
+  before_save :sanitize, if: :will_save_change_to_geog?
+  after_save :cache_derivatives, :if => [:automatically_cache_derivatives?, :saved_change_to_geog?]
 
   def self.cache_key
     result = connection.select_one(all.select('max(id) AS max, count(*) AS count').to_sql)
     "#{result['max']}-#{result['count']}"
   end
 
+  # for Rails >= 5 ActiveRecord collections we override the collection_cache_key
+  # to prevent Rails doing its default query on `updated_at`
+  def self.collection_cache_key(_collection, _timestamp_column)
+    self.cache_key
+  end
+
   def self.with_metadata(k, v)
     if k.present? && v.present?
       where('metadata->? = ?', k, v)
@@ -82,6 +91,14 @@ class AbstractFeature < ActiveRecord::Base
     return envelope_json.values_at(0,2)
   end
 
+  def self.without_caching_derivatives(&block)
+    old = automatically_cache_derivatives
+    self.automatically_cache_derivatives = false
+    block.call
+  ensure
+    self.automatically_cache_derivatives = old
+  end
+
   def self.cache_derivatives(options = {})
     update_all <<-SQL.squish
       geom         = ST_Transform(geog::geometry, #{detect_srid('geom')}),
@@ -132,7 +149,7 @@ class AbstractFeature < ActiveRecord::Base
   end
 
   def cache_derivatives(*args)
-    self.class.where(:id => self.id).cache_derivatives(*args)
+    self.class.default_scoped.where(:id => self.id).cache_derivatives(*args)
   end
 
   def kml(options = {})
@@ -149,10 +166,6 @@ class AbstractFeature < ActiveRecord::Base
     @make_valid
   end
 
-  def wkt
-    ActiveRecord::Base.connection.select_value("SELECT ST_ASEWKT('#{geom}')")
-  end
-
   private
 
   def make_valid

data/app/models/feature.rb

@@ -11,6 +11,16 @@ class Feature < AbstractFeature
 
   after_save :refresh_aggregate, if: :automatically_refresh_aggregate?
 
+  # Features are used for display so we also cache their KML representation
+  def self.cache_derivatives(options = {})
+    super
+    update_all <<-SQL.squish
+      kml          = ST_AsKML(geog, 6),
+      kml_lowres   = ST_AsKML(geom_lowres, #{options.fetch(:lowres_precision, lowres_precision)}),
+      kml_centroid = ST_AsKML(centroid)
+    SQL
+  end
+
   def self.defer_aggregate_refresh(&block)
     start_at = Feature.maximum(:id).to_i + 1
     output = without_aggregate_refresh(&block)
@@ -30,9 +40,10 @@ class Feature < AbstractFeature
 
   def self.refresh_aggregates
     # Find one feature from each spatial model and trigger the aggregate feature refresh
-    ids = select('MAX(id)')
-            .where.not(:spatial_model_type => nil, :spatial_model_id => nil)
+    ids = where.not(:spatial_model_type => nil)
+            .where.not(:spatial_model_id => nil)
             .group('spatial_model_type, spatial_model_id')
+            .pluck('MAX(id)')
 
     # Unscope so that newly built AggregateFeatures get their type column set correctly
     AbstractFeature.unscoped { where(:id => ids).find_each(&:refresh_aggregate) }
@@ -49,14 +60,4 @@ class Feature < AbstractFeature
     # this field blank.
     spatial_model_id? && automatically_refresh_aggregate && saved_change_to_geog?
   end
-
-  # Features are used for display so we also cache their KML representation
-  def self.cache_derivatives(options = {})
-    super
-    update_all <<-SQL.squish
-      kml          = ST_AsKML(geog, 6),
-      kml_lowres   = ST_AsKML(geom_lowres, #{options.fetch(:lowres_precision, lowres_precision)}),
-      kml_centroid = ST_AsKML(centroid)
-    SQL
-  end
 end

data/lib/spatial_features.rb

@@ -3,9 +3,6 @@ require 'delayed_job_active_record'
 require 'rgeo/shapefile'
 require 'nokogiri'
 require 'zip'
-require 'googleauth'
-require 'google/apis/fusiontables_v2'
-require 'google/apis/drive_v3'
 
 # LIB
 require 'spatial_features/caching'
@@ -15,16 +12,12 @@ require 'spatial_features/controller_helpers/spatial_extensions'
 require 'spatial_features/download'
 require 'spatial_features/unzip'
 require 'spatial_features/utils'
+require 'spatial_features/validation'
 
 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_fusion_table_features'
-require 'spatial_features/has_fusion_table_features/api'
-require 'spatial_features/has_fusion_table_features/configuration'
-require 'spatial_features/has_fusion_table_features/service'
-
 require 'spatial_features/importers/base'
 require 'spatial_features/importers/file'
 require 'spatial_features/importers/kml'
@@ -38,7 +31,6 @@ require 'spatial_features/engine'
 
 # Load the act method
 ActiveRecord::Base.send :extend, SpatialFeatures::ActMethod
-ActiveRecord::Base.send :extend, SpatialFeatures::FusionTables::ActMethod
 
 # Suppress date warnings when unzipping KMZ saved by Google Earth, see https://github.com/rubyzip/rubyzip/issues/112
 Zip.warn_invalid_date = false

data/lib/spatial_features/controller_helpers/spatial_extensions.rb

@@ -6,8 +6,6 @@ module SpatialExtensions
       model.failed_feature_update_jobs.destroy_all
       model.delay_update_features!
     end
-
-    redirect_to :back
   end
 
   def abstract_proximity_action(scope, target, distance, &block)

data/lib/spatial_features/download.rb

@@ -12,7 +12,7 @@ module SpatialFeatures
     def self.open(file, unzip: nil, **unzip_options)
       file = Kernel.open(file)
       file = normalize_file(file) if file.is_a?(StringIO)
-      if Unzip.is_zip?(file)
+      if unzip && Unzip.is_zip?(file)
         file = find_in_zip(file, find: unzip, **unzip_options)
       end
       return file
@@ -26,6 +26,12 @@ module SpatialFeatures
       end
     end
 
+    def self.entries(file)
+      file = Kernel.open(file)
+      file = normalize_file(file) if file.is_a?(StringIO)
+      Unzip.entries(file)
+    end
+
     def self.find_in_zip(file, find:, **unzip_options)
       return File.open(Unzip.paths(file, :find => find, **unzip_options))
     end

data/lib/spatial_features/has_spatial_features.rb

@@ -88,16 +88,16 @@ module SpatialFeatures
 
     # 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?
-      column_names.include? 'features_hash'
+      owner_class_has_loaded_column?('features_hash')
     end
 
     # Returns true if the model stores a cache of the features area
     def has_features_area?
-      column_names.include? 'features_area'
+      owner_class_has_loaded_column?('features_area')
     end
 
     def area_in_square_meters
-      features.area_in_square_meters
+      features.area
     end
 
     private
@@ -160,6 +160,12 @@ module SpatialFeatures
       scope = scope.where(:spatial_model_id => other) unless Utils.class_of(other) == other
       return scope
     end
+
+    def owner_class_has_loaded_column?(column_name)
+      return false unless connected?
+      return false unless table_exists?
+      column_names.include? column_name
+    end
   end
 
   module InstanceMethods
@@ -184,7 +190,11 @@ module SpatialFeatures
     end
 
     def features?
-      features.present?
+      if features.loaded?
+        features.present?
+      else
+        features.exists?
+      end
     end
 
     def intersects?(other)
@@ -198,7 +208,7 @@ module SpatialFeatures
     end
 
     def features_area_in_square_meters
-      @features_area_in_square_meters ||= features.area
+      aggregate_feature&.area
     end
 
     def total_intersection_area_in_square_meters(other)

data/lib/spatial_features/has_spatial_features/feature_import.rb

@@ -79,14 +79,24 @@ module SpatialFeatures
     end
 
     def import_features(imports, skip_invalid)
-      self.features.delete_all
+      features.delete_all
       valid, invalid = Feature.defer_aggregate_refresh do
-        imports.flat_map(&:features).partition do |feature|
-          feature.spatial_model = self
-          feature.save
+        Feature.without_caching_derivatives do
+          imports.flat_map(&:features).partition do |feature|
+            feature.spatial_model = self
+            feature.save
+          end
         end
       end
 
+      if persisted?
+        features.reset # Reset the association cache because we've updated the features
+        features.cache_derivatives
+      else
+        self.features = valid # Assign the features so when we save this record we update the foreign key on the features
+        Feature.where(id: features).cache_derivatives
+      end
+
       errors = imports.flat_map(&:errors)
       invalid.each do |feature|
         errors << "Feature #{feature.name}: #{feature.errors.full_messages.to_sentence}"
@@ -98,7 +108,7 @@ module SpatialFeatures
         raise ImportError, "Error updating #{self.class} #{self.id}. #{errors.to_sentence}"
       end
 
-      self.features = valid
+      return features
     end
 
     def features_cache_key_matches?(cache_key)

data/lib/spatial_features/importers/kml.rb

@@ -14,10 +14,14 @@ module SpatialFeatures
             else
               metadata = {}
             end
-    
+
             next if blank_feature?(feature)
 
-            yield OpenStruct.new(:feature_type => sql_type, :geog => geom_from_kml(feature), :name => name, :metadata => metadata)
+            geog = geom_from_kml(feature)
+
+            next if geog.blank?
+
+            yield OpenStruct.new(:feature_type => sql_type, :geog => geog, :name => name, :metadata => metadata)
           end
         end
       end
@@ -27,7 +31,16 @@ module SpatialFeatures
       end
 
       def geom_from_kml(kml)
-        ActiveRecord::Base.connection.select_value("SELECT ST_GeomFromKML(#{ActiveRecord::Base.connection.quote(kml.to_s)})")
+        geom = 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)
+        Thread.new do
+          geom = ActiveRecord::Base.connection.select_value("SELECT ST_GeomFromKML(#{ActiveRecord::Base.connection.quote(kml.to_s)})")
+        rescue ActiveRecord::StatementInvalid => e # Discard Invalid KML features
+          geom = nil
+        end.join
+
+        return geom
       end
 
       def extract_metadata(placemark)

data/lib/spatial_features/importers/shapefile.rb

@@ -12,7 +12,7 @@ module SpatialFeatures
       end
 
       def cache_key
-        @cache_key ||= Digest::MD5.hexdigest(features.to_json)
+        @cache_key ||= Digest::MD5.file(archive).to_s
       end
 
       private
@@ -49,13 +49,27 @@ module SpatialFeatures
         SQL
       end
 
+
       def file
-        @file ||= Download.open(@data, unzip: /\.shp$/, downcase: true)
+        @file ||= begin
+          validate_file!
+          Download.open(archive, unzip: /\.shp$/, downcase: true)
+        end
+      end
+
+      def validate_file!
+        return unless Unzip.is_zip?(archive)
+        Validation.validate_shapefile_archive!(Download.entries(archive), default_proj4_projection: default_proj4_projection)
+      end
+
+      def archive
+        @archive ||= Download.open(@data)
       end
     end
 
     # ERRORS
     class IndeterminateShapefileProjection < SpatialFeatures::ImportError; end
     class IncompleteShapefileArchive < SpatialFeatures::ImportError; end
+    class InvalidShapefileArchive < SpatialFeatures::ImportError; end
   end
 end

data/lib/spatial_features/validation.rb

@@ -0,0 +1,55 @@
+module SpatialFeatures
+  module Validation
+    # SHP file must come first
+    REQUIRED_SHAPEFILE_COMPONENT_EXTENSIONS = %w[shp shx dbf prj].freeze
+
+    # Check if a shapefile archive includes the required component files, otherwise
+    # raise an exception.
+    #
+    # @param [Zip::File] zip_file                 A Zip::File object
+    # @param [String] default_proj4_projection    Optional, if supplied we don't raise an exception when we're missing a .PRJ file
+    # @param [Boolean] allow_generic_zip_files    When true, we skip validation entirely if the archive does not contain a .SHP file
+    def self.validate_shapefile_archive!(zip_file, default_proj4_projection: nil, allow_generic_zip_files: false)
+      zip_file_entries = zip_file.entries.each_with_object({}) do |f, obj|
+        ext = File.extname(f.name).downcase[1..-1]
+        next unless ext
+
+        if ext.casecmp?("shp") && obj.key?(ext)
+          raise ::SpatialFeatures::Importers::InvalidShapefileArchive, "Zip files that contain multiple Shapefiles are not supported. Please separate each Shapefile into its own zip file."
+        end
+
+        obj[ext] = File.basename(f.name, '.*')
+      end
+
+      shapefile_basename = zip_file_entries["shp"]
+      unless shapefile_basename
+        # not a shapefile archive but we don't care
+        return if allow_generic_zip_files
+
+        raise ::SpatialFeatures::Importers::IncompleteShapefileArchive, "Shapefile archive is missing a SHP file"
+      end
+
+      REQUIRED_SHAPEFILE_COMPONENT_EXTENSIONS[1..-1].each do |ext|
+        ext_basename = zip_file_entries[ext]
+        next if ext_basename&.casecmp?(shapefile_basename)
+
+        case ext
+        when "prj"
+          # special case for missing projection files to allow using default_proj4_projection
+          next if default_proj4_projection
+
+          raise ::SpatialFeatures::Importers::IndeterminateShapefileProjection, "Shapefile archive is missing a projection file: #{expected_component_path(shapefile_basename, ext)}"
+        else
+          # for all un-handled cases of missing files raise the more generic error
+          raise ::SpatialFeatures::Importers::IncompleteShapefileArchive, "Shapefile archive is missing a required file: #{expected_component_path(shapefile_basename, ext)}"
+        end
+      end
+
+      true
+    end
+
+    def self.expected_component_path(basename, ext)
+      "#{basename}.#{ext}"
+    end
+  end
+end

data/lib/spatial_features/version.rb

@@ -1,3 +1,3 @@
 module SpatialFeatures
-  VERSION = "2.12.2"
+  VERSION = "2.15.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spatial_features
 version: !ruby/object:Gem::Version
-  version: 2.12.2
+  version: 2.15.0
 platform: ruby
 authors:
 - Ryan Wallace
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-23 00:00:00.000000000 Z
+date: 2021-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -20,7 +20,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -30,7 +30,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: delayed_job_active_record
   requirement: !ruby/object:Gem::Requirement
@@ -51,28 +51,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -87,34 +87,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: googleauth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-- !ruby/object:Gem::Dependency
-  name: google-api-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: chroma
   requirement: !ruby/object:Gem::Requirement
@@ -135,14 +107,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -180,10 +152,6 @@ files:
 - lib/spatial_features/controller_helpers/spatial_extensions.rb
 - lib/spatial_features/download.rb
 - lib/spatial_features/engine.rb
-- lib/spatial_features/has_fusion_table_features.rb
-- lib/spatial_features/has_fusion_table_features/api.rb
-- 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/feature_import.rb
 - lib/spatial_features/has_spatial_features/queued_spatial_processing.rb
@@ -198,6 +166,7 @@ files:
 - lib/spatial_features/uncached_result.rb
 - lib/spatial_features/unzip.rb
 - lib/spatial_features/utils.rb
+- lib/spatial_features/validation.rb
 - lib/spatial_features/venn_polygons.rb
 - lib/spatial_features/version.rb
 - lib/tasks/spatial_features_tasks.rake

data/lib/spatial_features/has_fusion_table_features.rb

@@ -1,95 +0,0 @@
-module SpatialFeatures
-  module FusionTables
-    module ActMethod
-      def has_fusion_table_features(options = {})
-        class_attribute :fusion_table_features_options
-        self.fusion_table_features_options = options
-
-        after_update_features :expire_fusion_table
-
-        include InstanceMethods
-        extend ClassMethods
-      end
-    end
-
-    module ClassMethods
-      def to_fusion_condition
-        sanitize_sql(["spatial_model_id IN (?)", pluck(:id)])
-      end
-
-      def update_fusion_tables(group_options = {})
-        fusion_table_groups(group_options) do |fusion_table_id, records, group_features|
-          API.set_features(fusion_table_id, group_features, :colour => fusion_table_features_options[:colour])
-        end
-      end
-
-      def delete_fusion_tables(group_options = {})
-        fusion_table_groups(group_options) do |fusion_table_id, records, group_features|
-          API.delete_table(fusion_table_id)
-        end
-        @fusion_table_id_cache = nil
-      end
-
-      def acts_like_fusion_table_features?
-        true
-      end
-
-      def fusion_table_id_cache
-        @fusion_table_id_cache ||= Hash.new {|hash, table_name| hash[table_name] = API.find_or_create_table(table_name) }
-          .merge(API.tables.collect {|table| [table.name, table.table_id] }.to_h) # Warm the cache
-      end
-
-      private
-
-      def fusion_table_groups(only: [], except: [])
-        groups = all.group_by(&:fusion_table_id)
-        groups.select! {|fusion_table_id, _| Array.wrap(only).include?(fusion_table_id) } if only.present?
-        groups.select! {|fusion_table_id, _| !Array.wrap(except).include?(fusion_table_id) } if except.present?
-        groups.each do |fusion_table_id, records|
-          yield fusion_table_id, records, features.where(:spatial_model_id => records)
-        end
-      end
-    end
-
-    module InstanceMethods
-      def acts_like_fusion_table_features?
-        true
-      end
-
-      def stale_fusion_table?
-        @stale_fusion_table
-      end
-
-      def expire_fusion_table
-        @stale_fusion_table = true
-      end
-
-      def update_fusion_table
-        self.class.update_fusion_tables(only: fusion_table_id)
-      end
-
-      def delete_fusion_table
-        self.class.delete_fusion_tables(only: fusion_table_id)
-      end
-
-      def fusion_table_id
-        self.class.fusion_table_id_cache[fusion_table_name]
-      end
-
-      def fusion_table_name
-        case fusion_table_features_options[:table_name]
-        when Symbol
-          send(fusion_table_features_options[:table_name])
-        when String
-          fusion_table_features_options[:table_name]
-        else
-          self.class.table_name
-        end
-      end
-
-      def to_fusion_condition
-        self.class.where(:id => self).to_fusion_condition
-      end
-    end
-  end
-end

data/lib/spatial_features/has_fusion_table_features/api.rb

@@ -1,111 +0,0 @@
-module SpatialFeatures
-  module FusionTables
-    module API
-      extend self
-
-      FEATURE_COLUMNS = {
-        :name => 'STRING',
-        :spatial_model_type => 'STRING',
-        :spatial_model_id => 'NUMBER',
-        :kml_lowres => 'LOCATION',
-        :colour => 'STRING',
-        :metadata => 'STRING'
-      }
-      TABLE_STYLE = {
-        :polygon_options => { :fill_color_styler => { :kind => 'fusiontables#fromColumn', :column_name => 'colour' },
-                              :stroke_color_styler => { :kind => 'fusiontables#fromColumn', :column_name => 'colour' },
-                              :stroke_weight => 1
-                            },
-        :polyline_options => { :stroke_color_styler => { :kind => 'fusiontables#fromColumn', :column_name => 'colour'} }
-      }
-
-      TABLE_TEMPLATE = {
-        :body => "<h3>{name}</h3>{metadata}"
-      }
-
-      def find_or_create_table(name)
-        find_table(name) || create_table(name)
-      end
-
-      def create_table(name)
-        table_id = service.create_table(name, FEATURE_COLUMNS.collect {|name, type| {:name => name, :type => type} })
-        service.share_table(table_id)
-        service.insert_style(table_id, TABLE_STYLE)
-        service.insert_template(table_id, TABLE_TEMPLATE)
-        return table_id
-      end
-
-      def find_table(name)
-        service.tables.find {|table| table.name == name }.try(:table_id)
-      end
-
-      def delete_table(table_id)
-        service.delete_table(table_id)
-      end
-
-      def tables
-        service.tables
-      end
-
-      def set_features(table_id, features, colour: nil)
-        service.replace_rows(table_id, features_to_csv(features, colour))
-      end
-
-      def set_style(table_id, style)
-        service.style_ids(table_id).each do |style_id|
-          service.delete_style(table_id, style_id)
-        end
-        service.insert_style(table_id, style)
-      end
-
-      def service
-        @service ||= Service.new(Configuration.service_account_credentials)
-      end
-
-      private
-
-      def features_to_csv(features, colour)
-        ActiveRecord::Associations::Preloader.new.preload(features, :spatial_model) if colour.is_a?(Symbol)
-
-        csv = CSV.generate do |csv|
-          features.each do |feature|
-            csv << FEATURE_COLUMNS.keys.collect do |attribute|
-              case attribute
-              when :colour
-                render_feature_colour(feature, colour)
-              when :metadata
-                render_feature_metadata(feature)
-              else
-                feature.send(attribute)
-              end
-            end
-          end
-        end
-
-        file = Tempfile.new('features')
-        file.write(csv)
-        return file
-      end
-
-      def render_feature_metadata(feature)
-        feature.metadata.collect do |name, val|
-          "<b>#{name}:</b> #{val}"
-        end.join('<br/>')
-      end
-
-      def render_feature_colour(feature, colour)
-        case colour
-        when Symbol
-          feature.spatial_model.send(colour)
-        when Proc
-          colour.call(feature)
-        else
-          colour
-        end.paint.to_ft_hex
-
-      rescue Chroma::Errors::UnrecognizedColor
-        nil
-      end
-    end
-  end
-end

data/lib/spatial_features/has_fusion_table_features/configuration.rb

@@ -1,15 +0,0 @@
-module SpatialFeatures
-  module FusionTables
-    def self.config
-      if block_given?
-        yield Configuration
-      else
-        Configuration
-      end
-    end
-
-    module Configuration
-      mattr_accessor :service_account_credentials
-    end
-  end
-end

data/lib/spatial_features/has_fusion_table_features/service.rb

@@ -1,104 +0,0 @@
-module SpatialFeatures
-  module FusionTables
-    class Service
-      APPLICATION_NAME = 'Fusion Tables + Spatial Features'
-      GOOGLE_AUTH_SCOPES = %w(https://www.googleapis.com/auth/fusiontables https://www.googleapis.com/auth/drive)
-
-      def initialize(service_account_credentials_path)
-        @authorization = get_authorization(service_account_credentials_path, GOOGLE_AUTH_SCOPES)
-      end
-
-      def table_ids
-        tables.collect(&:table_id)
-      end
-
-      def tables
-        fusion_tables_service.list_tables(max_results: 10000).items || []
-      end
-
-      def create_table(name, columns = [], table_options = {})
-        table_object = {:name => name, :columns => columns, :is_exportable => true}.merge(table_options)
-        fusion_tables_service.insert_table(table_object, :fields => 'table_id').table_id
-      end
-
-      def delete_table(table_id)
-        fusion_tables_service.delete_table(table_id)
-      end
-
-      def style_ids(table_id)
-        styles(table_id).collect(&:style_id)
-      end
-
-      def styles(table_id)
-        fusion_tables_service.list_styles(table_id).items
-      end
-
-      def delete_style(table_id, style_id)
-        fusion_tables_service.delete_style(table_id, style_id, :fields => nil)
-      end
-
-      def insert_style(table_id, style)
-        style.reverse_merge! 'name' => 'default_table_style', 'isDefaultForTable' => true
-        fusion_tables_service.insert_style(table_id, style, :fields => 'styleId')
-      end
-
-      def delete_template(table_id, template_id)
-        fusion_tables_service.delete_template(table_id, template_id, :fields => nil)
-      end
-
-      def insert_template(table_id, template)
-        template.reverse_merge! 'name' => 'default_table_template'
-        fusion_tables_service.insert_template(table_id, template, :fields => 'templateId')
-      end
-
-      def delete_row(table_id, row_id)
-        fusion_tables_service.sql_query("DELETE FROM #{table_id} WHERE ROWID = #{row_id}")
-      end
-
-      def row_ids(table_id, conditions = {})
-        clause = conditions.collect {|column, value| ActiveRecord::Base.send(:sanitize_sql_array, ["? IN (?)", column, value]) }.join(' AND ')
-        where = "WHERE #{clause}" if clause.present?
-        return fusion_tables_service.sql_query_get("SELECT rowid FROM #{table_id} #{where}}").rows.flatten
-      end
-
-      # Process mutliple commands in a single HTTP request
-      def bulk(&block)
-        fusion_tables_service.batch do
-          block.call(self)
-        end
-      end
-
-      def replace_rows(table_id, csv)
-        fusion_tables_service.replace_table_rows(table_id, :upload_source => csv, :options => {:open_timeout_sec => 1.hour})
-      end
-
-      def upload_rows(table_id, csv)
-        fusion_tables_service.import_rows(table_id, :upload_source => csv, :options => {:open_timeout_sec => 1.hour})
-      end
-
-      def share_table(table_id)
-        permission = {:type => 'anyone', :role => 'reader', :withLink => true}
-        drive_service.create_permission(table_id, permission, :fields => 'id')
-      end
-
-      def fusion_tables_service
-        @fusion_tables_service ||= Google::Apis::FusiontablesV2::FusiontablesService.new.tap do |service|
-          service.client_options.application_name = APPLICATION_NAME
-          service.authorization = @authorization
-        end
-      end
-
-      def drive_service
-        @drive_service ||= Google::Apis::DriveV3::DriveService.new.tap do |drive|
-          drive.client_options.application_name = APPLICATION_NAME
-          drive.authorization = @authorization
-        end
-      end
-
-      def get_authorization(service_account_credentials_path, scopes)
-        ENV['GOOGLE_APPLICATION_CREDENTIALS'] = service_account_credentials_path
-        return Google::Auth.get_application_default(scopes)
-      end
-    end
-  end
-end