kithe 1.1.2 → 2.0.0.pre.alpha1

data/spec/models/kithe/asset/asset_create_derivatives_spec.rb

@@ -27,8 +27,12 @@ describe "Kithe::Asset derivative definitions", queue_adapter: :test do
     ).tap do |a|
       # We want to promote without create_derivatives being automatically called
       # as usual, so we can test create_derivatives manually.
-      a.file_attacher.set_promotion_directives(skip_callbacks: true)
+      a.file_attacher.set_promotion_directives(create_derivatives: false)
       a.promote
+
+      # Precondition assumptions for our test setup to be valid
+      expect(a.file_attacher.stored?).to be(true)
+      expect(a.derivatives).to be_empty
     end
   end
 
@@ -101,7 +105,7 @@ describe "Kithe::Asset derivative definitions", queue_adapter: :test do
     asset.create_derivatives
 
     jpg_deriv = asset.derivatives.find {|d| d.key == "a_jpg"}
-    expect(jpg_deriv.file.storage_key).to eq("kithe_derivatives")
+    expect(jpg_deriv.file.storage_key).to eq(:kithe_derivatives)
   end
 
 
@@ -147,7 +151,7 @@ describe "Kithe::Asset derivative definitions", queue_adapter: :test do
       deriv = asset.derivatives.first
 
       expect(deriv).to be_present
-      expect(deriv.file.storage_key).to eq("store")
+      expect(deriv.file.storage_key).to eq(:store)
     end
   end
 

data/spec/models/kithe/asset/asset_promotion_hooks_spec.rb

@@ -15,6 +15,28 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
     )
   }
 
+  describe "before_promotion" do
+    temporary_class("TestAsset") do
+      Class.new(Kithe::Asset) do
+        before_promotion do
+          $metadata_in_before_promotion = self.file.metadata
+        end
+      end
+    end
+    before do
+      $metadata_in_before_promotion = nil
+    end
+
+    # we have a built-in before_promotion for metadata extraction,
+    # make sure it happens before any additional before_promotions,
+    # so they can eg use it to cancel
+    it "has access to automatic metadata extraction" do
+      unsaved_asset.save!
+      expect($metadata_in_before_promotion).to be_present
+      expect($metadata_in_before_promotion['sha512']).to be_present
+    end
+  end
+
   describe "before_promotion cancellation" do
     temporary_class("TestAsset") do
       Class.new(Kithe::Asset) do
@@ -28,23 +50,138 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
       end
     end
 
-    it "works" do
-      expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:store!)
+    describe "with inline promotion", queue_adapter: :test do
+      before do
+        unsaved_asset.file_attacher.set_promotion_directives(promote: :inline)
+      end
 
-      unsaved_asset.save!
-      unsaved_asset.reload
-      expect(unsaved_asset.stored?).to be(false)
+      it "cancels" do
+        expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:promote)
+
+        unsaved_asset.save!
+        unsaved_asset.reload
+        expect(unsaved_asset.reload.stored?).to be(false)
+      end
+
+      describe "with promotion_directives[:skip_callbacks]" do
+        it "doesn't cancel" do
+          expect_any_instance_of(Kithe::AssetUploader::Attacher).to receive(:promote).and_call_original
+
+          unsaved_asset.file_attacher.set_promotion_directives(skip_callbacks: true)
+          unsaved_asset.save!
+          unsaved_asset.reload
+
+          expect(unsaved_asset.stored?).to be(true)
+        end
+      end
     end
 
-    describe "with promotion_directives[:skip_callbacks]" do
-      it "doesn't cancel" do
-        expect_any_instance_of(Kithe::AssetUploader::Attacher).to receive(:store!).and_call_original
+    describe "with backgrounding promotion", queue_adapter: :inline do
+      it "cancels" do
+        expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:promote)
 
-        unsaved_asset.file_attacher.set_promotion_directives(skip_callbacks: true)
         unsaved_asset.save!
         unsaved_asset.reload
+        expect(unsaved_asset.stored?).to be(false)
+      end
+
+      describe "with promotion_directives[:skip_callbacks]" do
+        it "doesn't cancel" do
+          expect_any_instance_of(Kithe::AssetUploader::Attacher).to receive(:promote).and_call_original
+
+          unsaved_asset.file_attacher.set_promotion_directives(skip_callbacks: true)
+          unsaved_asset.save!
+          unsaved_asset.reload
+
+          expect(unsaved_asset.stored?).to be(true)
+        end
+      end
+    end
+
+
+    describe "assigning directly to store" do
+      temporary_class("TestAsset") do
+        Class.new(Kithe::Asset) do
+          before_promotion do
+            raise "Should not call before_promotion"
+          end
+
+          after_promotion do
+            raise "Should not call after_promotion"
+          end
+        end
+      end
+
+      let(:asset) {
+        TestAsset.create(title: "test")
+      }
+
+      let(:filepath) { Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg") }
+
+      describe "with inline promoting" do
+        before do
+          asset.file_attacher.set_promotion_directives(promote: :inline)
+        end
+
+        it "should not call callbacks" do
+          expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:promote)
+
+          asset.file_attacher.attach(File.open(filepath))
+          asset.save!
+
+          expect(asset.changed?).to be(false)
+          asset.reload
+          expect(asset.file).to be_present
+          expect(asset.stored?).to be(true)
+        end
+      end
+
+      describe "with background promoting", queue_adapter: :inline do
+        before do
+          asset.file_attacher.set_promotion_directives(promote: :background)
+        end
+
+        it "should not call callbacks" do
+          expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:promote)
+
+          asset.file_attacher.attach(File.open(filepath))
+          asset.save!
+
+          expect(asset.changed?).to be(false)
+          asset.reload
+          expect(asset.file).to be_present
+          expect(asset.stored?).to be(true)
+        end
+      end
+    end
+
+
+    describe "calling Asset#promote directly", queue_adapter: :inline do
+      before do
+        unsaved_asset.file_attacher.set_promotion_directives(promote: false)
+        unsaved_asset.save!
+        # precondition
+        expect(unsaved_asset.reload.file_attacher.cached?).to be(true)
+      end
+
+      it "cancels" do
+        expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:promote)
+
+        unsaved_asset.promote
+        unsaved_asset.reload
+        expect(unsaved_asset.stored?).to be(false)
+      end
+
+      describe "with promotion_directives[:skip_callbacks]" do
+        it "doesn't cancel" do
+          expect_any_instance_of(Kithe::AssetUploader::Attacher).to receive(:promote).and_call_original
 
-        expect(unsaved_asset.stored?).to be(true)
+          unsaved_asset.file_attacher.set_promotion_directives(skip_callbacks: true)
+          unsaved_asset.promote
+          unsaved_asset.reload
+
+          expect(unsaved_asset.stored?).to be(true)
+        end
       end
     end
   end
@@ -56,7 +193,7 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
       receiver = after_promotion_receiver
       Class.new(Kithe::Asset) do
         after_promotion do
-          receiver.call
+          receiver.call(self)
         end
       end
     end
@@ -66,6 +203,29 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
       unsaved_asset.save!
     end
 
+    describe "with inline promotion" do
+      before do
+        unsaved_asset.file_attacher.set_promotion_directives(promote: :inline)
+      end
+
+      # this is actually what's checking for following example...
+      let(:after_promotion_receiver) do
+        proc do |asset|
+          expect(asset.changed?).to be(false)
+
+          asset.reload
+
+          expect(asset.stored?).to be(true)
+          expect(asset.sha512).to be_present
+        end
+      end
+
+      it "asset has metadata and is finalized" do
+        expect(after_promotion_receiver).to receive(:call).and_call_original
+        unsaved_asset.save!
+      end
+    end
+
     describe "with promotion_directives[:skip_callbacks]" do
       it "doesn't call" do
         expect(after_promotion_receiver).not_to receive(:call)
@@ -178,7 +338,7 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
     let!(:existing_file) {  saved_asset.file }
 
     it "can cancel deletion" do
-      expect(Kithe::AssetUploader::Attacher).not_to receive(:delete)
+      expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:destroy)
 
 
       saved_asset.set_promotion_directives(delete: false)
@@ -224,5 +384,12 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
       asset.set_promotion_directives(promote: :inline)
       expect(asset.file_attacher.promotion_directives).to eq("promote" => "inline")
     end
+
+    it "setting from instance writer is aggregative" do
+      Kithe::Asset.promotion_directives = { promote: :inline }
+      asset = Kithe::Asset.new
+      asset.set_promotion_directives(create_derivatives: false)
+      expect(asset.file_attacher.promotion_directives).to eq("promote" => "inline", "create_derivatives" => "false")
+    end
   end
 end

data/spec/models/kithe/asset_spec.rb

@@ -107,7 +107,7 @@ RSpec.describe Kithe::Asset, type: :model do
       asset.save!
       asset.reload
 
-      expect(asset.file.storage_key).to eq(asset.file_attacher.store.storage_key.to_s)
+      expect(asset.file.storage_key).to eq(asset.file_attacher.store.storage_key.to_sym)
       expect(asset.stored?).to be true
       expect(asset.file.read).to include("Example Response")
       expect(asset.file.id).to end_with(".html") # no query params
@@ -120,6 +120,7 @@ RSpec.describe Kithe::Asset, type: :model do
       asset.file = {"id" => "http://www.example.com/bar.html?foo=bar",
                     "storage" => "remote_url",
                     "headers" => {"Authorization" => "Bearer TestToken"}}
+
       asset.save!
 
       expect(
@@ -172,7 +173,7 @@ RSpec.describe Kithe::Asset, type: :model do
         file: File.open(Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg"))
       ).tap do |a|
         a.file_attacher.set_promotion_directives(skip_callbacks: true)
-        a.promote
+        #a.promote
         a.reload
         a.update_derivative(:existing, StringIO.new("content"))
       end

data/spec/models/kithe/derivative_spec.rb

@@ -52,7 +52,7 @@ RSpec.describe Kithe::Derivative, type: :model, queue_adapter: :test do
       # file is stored
       expect(derivative.key).to eq(key)
       expect(derivative.file).to be_present
-      expect(derivative.file.storage_key).to eq("kithe_derivatives")
+      expect(derivative.file.storage_key).to eq(:kithe_derivatives)
       expect(derivative.file.read).to eq(dummy_content)
 
       # some metadata we got
@@ -63,7 +63,7 @@ RSpec.describe Kithe::Derivative, type: :model, queue_adapter: :test do
       expect(derivative.file.metadata["filename"]).to eq("#{asset.friendlier_id}_some_derivative.jpeg")
 
       # path on storage is nice and pretty
-      expect(derivative.file.id).to match %r{\A#{asset.id}/#{key}/[a-f0-9]+\.jpg\Z}
+      expect(derivative.file.id).to match %r{\A#{asset.id}/#{key}/[a-f0-9]+\.jpeg\Z}
     end
 
     it "can add a derivative with custom storage location" do
@@ -72,11 +72,11 @@ RSpec.describe Kithe::Derivative, type: :model, queue_adapter: :test do
       expect(derivative).to be_present
       derivative.reload
       expect(derivative.file).to be_present
-      expect(derivative.file.storage_key).to eq("store")
+      expect(derivative.file.storage_key).to eq(:store)
     end
 
     it "can add a derivative with custom metadata" do
-      derivative = asset.update_derivative(key, dummy_io, metadata: { foo: "bar" })
+      derivative = asset.update_derivative(key, dummy_io, metadata: { "foo" => "bar" })
       expect(derivative).to be_present
       expect(derivative.file.metadata["size"]).to eq(dummy_content.length)
       expect(derivative.file.metadata["foo"]).to eq("bar")

data/spec/shrine/kithe_multi_cache_spec.rb

@@ -22,7 +22,7 @@ describe Shrine::Plugins::KitheMultiCache do
   it "can promote from additional cache" do
     extra_storage.upload(fakeio("test_content"), "test_id")
     attacher.assign({"id" => "test_id", "storage" => "additional_one"}.to_json)
-    attacher.promote(attacher.get)
+    attacher.promote
 
     uploaded_file = attacher.get
     expect(uploaded_file).not_to be_nil

data/spec/spec_helper.rb

@@ -130,7 +130,7 @@ end
 # https://github.com/shrinerb/shrine/pull/443
 #
 require 'sane_patch'
-SanePatch.patch("shrine", "< 3") do
+SanePatch.patch("shrine", "< 3.2.2") do
   require 'shrine/storage/memory'
   class Shrine::Storage::Memory
     def open(id, *)

data/spec/test_support/shrine_spec_support.rb

@@ -3,6 +3,7 @@ module ShrineSpecSupport
   # https://github.com/shrinerb/shrine/blob/203c2c9a0c83815c9ded1b09d5d006b2a523579c/test/support/generic_helper.rb#L6
   def test_uploader(storage_key = :store, &block)
     uploader_class = Class.new(Shrine)
+    uploader_class.plugin :model
     uploader_class.storages[:cache] = Shrine::Storage::Test.new
     uploader_class.storages[:store] = Shrine::Storage::Test.new
     uploader_class.class_eval(&block) if block
@@ -13,7 +14,7 @@ module ShrineSpecSupport
     uploader = test_uploader(*args, &block)
     Object.send(:remove_const, "TestUser") if defined?(TestUser) # for warnings
     user_class = Object.const_set("TestUser", Struct.new(:avatar_data, :id))
-    user_class.include uploader.class::Attachment.new(:avatar, **attachment_options)
+    user_class.include uploader.class::Attachment(:avatar, **attachment_options)
     user_class.new.avatar_attacher
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kithe
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0.pre.alpha1
 platform: ruby
 authors:
 - Jonathan Rochkind
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-28 00:00:00.000000000 Z
+date: 2020-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -70,14 +70,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: shrine-url
   requirement: !ruby/object:Gem::Requirement
@@ -376,7 +376,8 @@ files:
 - lib/kithe/version.rb
 - lib/shrine/plugins/kithe_accept_remote_url.rb
 - lib/shrine/plugins/kithe_multi_cache.rb
-- lib/shrine/plugins/kithe_promotion_hooks.rb
+- lib/shrine/plugins/kithe_promotion_callbacks.rb
+- lib/shrine/plugins/kithe_promotion_directives.rb
 - lib/shrine/plugins/kithe_storage_location.rb
 - lib/tasks/kithe_tasks.rake
 - lib/vendor/icc/sRGB2014.icc
@@ -483,12 +484,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 

data/lib/shrine/plugins/kithe_promotion_hooks.rb

@@ -1,138 +0,0 @@
-class Shrine
-  module Plugins
-    # This adds some features around shrine promotion that we found useful for dealing
-    # with backgrounding promotion.
-    #
-    # * It will run shrine uploader metadata extraction routines on _any promotion_,
-    #   also adding a `promoting: true` key to the shrine context for that metadata
-    #   extraction. (Using shrine refresh_metadata plugin)
-    #
-    # * We separately give our Kithe::Asset model class an activemodel callback
-    #   "promotion" hook. This plugin will call those callbacks around promotion (whether background
-    #   or foreground) -- before, after, or around.
-    #
-    #   If a callback does a `throw :abort` before promotion, it can cancel promotion. This could
-    #   be used to cancel promotion for a validation failure of some kind -- you'd want to somehow
-    #   store or notify what happened, otherwise to the app and it's users it will just look like
-    #   the thing was never promoted for unknown reasons.
-    #
-    #   After promotion hooks can be used to hook into things you want to do only after a promotion;
-    #   since promotion is backgrounded it would be otherwise inconvenient to execute something
-    #   only after promotion completes.
-    #
-    #   The default Kithe::Asset hooks into after_promotion to run derivatives creation
-    #   routines.
-    #
-    # * A special :promotion_directives key in the shrine context, which will be serialized
-    #   and restored to be preserved even accross background promotion. It is intended to hold
-    #   a hash of arbitrary key/values.  The special key :skip_callbacks, when set to a truthy
-    #   value, will prevent the promotion callbacks discussed above from happening. So if you want
-    #   to save a Kithe::Asset and have promotion happen as usual, but _not_ trigger any callbacks
-    #   (including derivative creation):
-    #
-    #   some_asset.file = some_assignable_file
-    #   some_asset.file_attacher.set_promotion_directives(skip_callbacks: true)
-    #   some_asset.save!
-    #
-    #   You can add other arbitrary keys which your own code in an uploader or promotion
-    #   callback may consult, with `set_promotion_directives` as above. To consult, check
-    #   attacher.promotion_directives[:some_key]
-    #
-    #   You can also set promotion directives globally for Kithe::Asset or a sub-class, in
-    #   a class method. Especially useful for batch processing.
-    #
-    #       Kithe::Asset.promotion_directives = { promote: :inline, create_derivatives: :inline }
-    #
-    class KithePromotionHooks
-      # whitelist of allowed promotion_directive keys, so we can raise on typos but still
-      # be extensible. Also serves as some documentation of what directives available.
-      class_attribute :allowed_promotion_directives,
-        instance_writer: false,
-        default: [:promote, :skip_callbacks, :create_derivatives, :delete]
-
-      def self.load_dependencies(uploader, *)
-        uploader.plugin :refresh_metadata
-        uploader.plugin :backgrounding
-      end
-
-      module AttacherClassMethods
-        # Overridden to restore any serialized promotion_directives to context[:promotion_directives],
-        # in backgrounding promotion.
-        def load(data)
-          super.tap do |attacher|
-            if data["promotion_directives"]
-              attacher.context[:promotion_directives] = data["promotion_directives"]
-            end
-          end
-        end
-      end
-
-      module AttacherMethods
-
-        # Set one or more promotion directives, in context[:promotion_directives], that
-        # will be serialized and restored to context for bg promotion. The values are intended
-        # to be simple strings or other json-serializable primitives.
-        #
-        # set_promotion_directives will merge it's results into existing promotion directives,
-        # existing keys will remain. So you can set multiple directives with multiple
-        # calls to set_promotion_directives, or pass multiple keys to one calls.
-        #
-        # @example
-        #     some_model.file_attacher.set_promotion_directives(skip_callbacks: true)
-        #     some_model.save!
-        def set_promotion_directives(hash)
-          # ActiveJob sometimes has trouble if there are symbols in there, somewhat
-          # unpredictably.
-          hash = hash.collect { |k, v| [k.to_s, v === Symbol ? v.to_s : v.to_s]}.to_h
-
-          unrecognized = hash.keys.collect(&:to_sym) - KithePromotionHooks.allowed_promotion_directives
-          unless unrecognized.length == 0
-            raise ArgumentError.new("Unrecognized promotion directive key: #{unrecognized.join('')}")
-          end
-
-          promotion_directives.merge!(hash)
-        end
-
-        # context[:promotion_directives], lazily initializing to hash for convenience.
-        def promotion_directives
-          context[:promotion_directives] ||= {}
-        end
-
-        # Overridden so our context[:promotion_directives] is serialized for
-        # backgrounding.
-        def dump
-          super.tap do |hash|
-            if context[:promotion_directives]
-              hash["promotion_directives"] = context[:promotion_directives]
-            end
-          end
-        end
-
-        # Overridden to:
-        # a) refresh metadata as part of promotion (adds `promoting: true` to context for such)
-        # b) call promotion callbacks on Asset model, unless `promotion_directives["skip_callbacks"]`
-        #    has been set.
-        def promote(uploaded_file = get, **options)
-          # insist on a metadata extraction, add a new key `promoting: true` in case
-          # anyone is interested.
-
-          uploaded_file.refresh_metadata!(**context.merge(options).merge(promoting: true))
-
-          # Now run ordinary promotion with activemodel callbacks from
-          # the Asset, which will automatically allow them to cancel promotion using
-          # ordinary activemodel callbacck technique of `throw :abort`.
-          if ( !promotion_directives["skip_callbacks"] &&
-               context[:record] &&
-               context[:record].class.respond_to?(:_promotion_callbacks) )
-            context[:record].run_callbacks(:promotion) do
-              super(uploaded_file, **options)
-            end
-          else
-            super(uploaded_file, **options)
-          end
-        end
-      end
-    end
-    register_plugin(:kithe_promotion_hooks, KithePromotionHooks)
-  end
-end