kithe 1.1.2 → 2.0.0.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bde82499d288e869bcdc6ca8155591e2dd2f5bbbd99da67fac721817eab72d6a
-  data.tar.gz: 451c606f2840694677c01eac5af0bc2594e9dba98837cdc56701ffa0774f4ee4
+  metadata.gz: 2821832cedc85d2e7cf3b503dfdbbfb8786b92eb9797067362534e76dc926390
+  data.tar.gz: 71af9ce59d1a87339503b832da9d9fc4b2622850e2d554116fa3c024236c36c3
 SHA512:
-  metadata.gz: 0de2c06c7a1f60d73da84697406a92350467ae0a8734a21e55ce2b29646a647fb5f06ef1ea0b58135758b86f8f48dbd5f95c1be92ef164ebf5e66429d1c3463d
-  data.tar.gz: d910de267c9b7753f4879147c0bf77e893507d87df923e27722c47a6002acc95ffc5414751a5dedc0ccac48e8845aa2e95cc290ed670bdf3f7fef554a84c7182
+  metadata.gz: fc7d9197215d95a0386dac5fe4ccef822b92c3459afbfb898f6a3a7f48b20245200c97fef3ea7659778e7d29962f26a631ba47e33860a364dccc58bb0e9c0a17
+  data.tar.gz: e93788031c2a37533a20f6fcaba47d88cea0c1a4a3f0657a5cadff7e6711e376bf49cb7eab6ea2139edc1a330fc125731f4eecf170178198f0ba244f80680b1e

data/app/jobs/kithe/asset_delete_job.rb

@@ -1,7 +1,10 @@
 module Kithe
   class AssetDeleteJob < Job
-    def perform(data)
-      AssetUploader::Attacher.delete(data)
+    def perform(attacher_class, data)
+      attacher_class = Object.const_get(attacher_class)
+
+      attacher = attacher_class.from_data(data)
+      attacher.destroy
     end
   end
 end

data/app/jobs/kithe/asset_promote_job.rb

@@ -1,7 +1,17 @@
 module Kithe
   class AssetPromoteJob < Job
-    def perform(data)
-      AssetUploader::Attacher.promote(data)
+    # note we add a `promotion_directives` arg on the end, differing from standard
+    # shrine. It is a hash.
+    def perform(attacher_class, record_class, record_id, name, file_data, promotion_directives)
+      attacher_class = Object.const_get(attacher_class)
+      record         = Object.const_get(record_class).find(record_id) # if using Active Record
+
+      attacher = attacher_class.retrieve(model: record, name: name, file: file_data)
+      attacher.set_promotion_directives(promotion_directives)
+
+      attacher.atomic_promote
+    rescue Shrine::AttachmentChanged, ActiveRecord::RecordNotFound
+      # attachment has changed or record has been deleted, nothing to do
     end
   end
 end

data/app/models/kithe/asset.rb

@@ -19,7 +19,7 @@ class Kithe::Asset < Kithe::Model
 
   # TODO we may need a way for local app to provide custom uploader class.
   # or just override at ./kithe/asset_uploader.rb locally?
-  include Kithe::AssetUploader::Attachment.new(:file)
+  include Kithe::AssetUploader::Attachment(:file)
 
   # for convenience, let's delegate some things to shrine parts
   delegate :content_type, :original_filename, :size, :height, :width, :page_count,
@@ -42,8 +42,11 @@ class Kithe::Asset < Kithe::Model
   # to happen only after asset is promoted, like derivatives.
   define_model_callbacks :promotion
 
+  before_promotion :refresh_metadata_before_promotion
   after_promotion :schedule_derivatives
 
+
+
   # Establish a derivative definition that will be used to create a derivative
   # when #create_derivatives is called, for instance automatically after promotion.
   #
@@ -183,15 +186,15 @@ class Kithe::Asset < Kithe::Model
 
   # Runs the shrine promotion step, that we normally have in backgrounding, manually
   # and in foreground. You might use this if a promotion failed and you need to re-run it,
-  # perhaps in bulk. It's also useful in tests.
+  # perhaps in bulk. It's also useful in tests. Also persists, using shrine `atomic_promote`.
   #
   # This will no-op unless the attached file is stored in cache -- that is, it
   # will no-op if the file has already been promoted. In this way it matches ordinary
   # shrine promotion. (Do we need an option to force promotion anyway?)
   #
-  # Note that calling `file_attacher.promote` on it's own won't do quite the right thing,
-  # and won't respect that the file is already cached.
-  def promote(action: :store, context: {})
+  # Note that calling `file_attacher.promote` or `atomic_promote` on it's own won't do
+  # quite the same things.
+  def promote(action: :store, **context)
     return unless file_attacher.cached?
 
     context = {
@@ -199,7 +202,7 @@ class Kithe::Asset < Kithe::Model
       record: self
     }.merge(context)
 
-    file_attacher.promote(file_attacher.get, **context)
+    file_attacher.atomic_promote(**context)
   end
 
   # The derivative creator sets metadata when it's created all derivatives
@@ -269,6 +272,11 @@ class Kithe::Asset < Kithe::Model
     end
   end
 
+  # Called by before_promotion hook
+  def refresh_metadata_before_promotion
+    file.refresh_metadata!(promoting: true)
+  end
+
   # Meant to be called in after_save hook, looks at activerecord dirty tracking in order
   # to removes all derivatives if the asset sha512 has changed
   def remove_invalid_derivatives

data/app/models/kithe/asset/derivative_updater.rb

@@ -51,8 +51,7 @@ class Kithe::Asset::DerivativeUpdater
 
     # add our derivative key to context when uploading, so Kithe::DerivativeUploader can
     # use it if needed.
-    uploaded_file = uploader.upload(io, record: deriv, metadata: metadata.merge(kithe_derivative_key: key))
-
+    uploaded_file = uploader.upload(io, record: deriv, metadata: metadata, kithe_derivative_key: key)
     optimistically_save_derivative(uploaded_file: uploaded_file, derivative: deriv)
   end
 
@@ -63,7 +62,7 @@ class Kithe::Asset::DerivativeUpdater
   # This method calls itself recursively to do that. Gives up after max_optimistic_tries,
   # at which point it'll just raise the constraint violation exception.
   def optimistically_save_derivative(uploaded_file:, derivative:, tries: 0)
-    derivative.file_attacher.set(uploaded_file)
+    derivative.file_attacher.change(uploaded_file)
     save_deriv_ensuring_unchanged_asset(derivative)
   rescue ActiveRecord::RecordNotUnique => e
     if tries < max_optimistic_tries

data/app/uploaders/kithe/asset_uploader.rb

@@ -30,6 +30,10 @@ module Kithe
     # so it can be submitted again.
     plugin :cached_attachment_data
 
+    # Used in a before_promotion hook to have our metadata extraction happen on
+    # promotion, possibly in the background.
+    plugin :refresh_metadata
+
     # Marcel analyzer is pure-ruby and fast. It's from Basecamp and is what
     # ActiveStorage uses. It is very similar to :mimemagic (and uses mimemagic
     # under the hood), but mimemagic seems not to be maintained with up to date
@@ -50,9 +54,10 @@ module Kithe
     end
 
     # Will save height and width to metadata for image types. (Won't for non-image types)
-    plugin :store_dimensions
+    # ignore errors (often due to storing a non-image file), consistent with shrine 2.x behavior.
+    plugin :store_dimensions, on_error: :ignore
 
-    # promotion and deletion will be in background.
+    # promotion and deletion will (sometimes) be in background.
     plugin :backgrounding
 
     # Useful in case consumers want it, and doesn't harm anything to be available.
@@ -63,16 +68,13 @@ module Kithe
     # feature can be used to make promotion not happen at all, or happen in foreground.
     #     asset.file_attacher.set_promotion_directives(promote: false)
     #     asset.file_attacher.set_promotion_directives(promote: "inline")
-    Attacher.promote do |data|
-      Kithe::TimingPromotionDirective.new(key: :promote, directives: data["promotion_directives"]) do |directive|
+    Attacher.promote_block do
+      Kithe::TimingPromotionDirective.new(key: :promote, directives: self.promotion_directives) do |directive|
         if directive.inline?
-          # Foreground, but you'll still need to #reload your asset to see changes,
-          # since backgrounding mechanism still reloads a new instance, sorry.
-          #Kithe::AssetPromoteJob.perform_now(data)
-          self.class.promote(data)
+          promote
         elsif directive.background?
-          # What shrine normally expects for backgrounding
-          Kithe::AssetPromoteJob.perform_later(data)
+          # What shrine normally expects for backgrounding, plus promotion_directives
+          Kithe::AssetPromoteJob.perform_later(self.class.name, record.class.name, record.id, name.to_s, file_data, self.promotion_directives)
         end
       end
     end
@@ -80,22 +82,19 @@ module Kithe
     # Delete using shrine backgrounding, but can be effected
     # by promotion_directives[:delete], similar to promotion above.
     # Yeah, not really a "promotion" directive, oh well.
-    Attacher.delete do |data|
-      Kithe::TimingPromotionDirective.new(key: :delete, directives: data["promotion_directives"]) do |directive|
+    Attacher.destroy_block do
+      Kithe::TimingPromotionDirective.new(key: :delete, directives: self.promotion_directives) do |directive|
         if directive.inline?
-          self.class.delete(data)
+          destroy
         elsif directive.background?
           # What shrine normally expects for backgrounding
-          Kithe::AssetDeleteJob.perform_later(data)
+          Kithe::AssetDeleteJob.perform_later(self.class.name, data)
         end
       end
     end
 
     plugin :add_metadata
 
-    # So we can assign a hash representing cached file
-    plugin :parsed_json
-
     # Makes files stored as /asset/#{asset_pk}/#{random_uuid}.#{original_suffix}
     plugin :kithe_storage_location
 
@@ -113,7 +112,7 @@ module Kithe
     # checksums until then anyway.
     plugin :signature
     add_metadata do |io, context|
-      if context[:action] == :store
+      if context[:action] != :cache
         {
           md5: calculate_signature(io, :md5),
           sha1: calculate_signature(io, :sha1),
@@ -123,8 +122,12 @@ module Kithe
     end
     metadata_method :md5, :sha1, :sha512
 
-    # This makes sure metadata is extracted on promotion, and also supports promotion
-    # callbacks (before/after/around) on the Kithe::Asset classes.
-    plugin :kithe_promotion_hooks
+
+    # Gives us (set_)promotion_directives methods on our attacher to
+    # house lifecycle directives, about whether promotion, deletion,
+    # derivatives happen in foreground, background, or not at all.
+    plugin :kithe_promotion_directives
+
+    plugin :kithe_promotion_callbacks
   end
 end

data/app/uploaders/kithe/derivative_uploader.rb

@@ -9,7 +9,10 @@ module Kithe
     plugin :activerecord
 
     plugin :determine_mime_type, analyzer: :marcel
-    plugin :store_dimensions
+
+    # ignore error, often from storing a non-image file which can't have dimensions
+    # extracted. behavior consistent with shrine 2.x.
+    plugin :store_dimensions, on_error: :ignore
 
     # Useful in case consumers want it, and doesn't harm anything to be available.
     # https://github.com/shrinerb/shrine/blob/master/doc/plugins/rack_response.md
@@ -32,10 +35,11 @@ module Kithe
     def extract_metadata(io, context = {})
       result = super
 
-      if context.dig(:metadata, :kithe_derivative_key) &&
+      if context[:kithe_derivative_key] &&
          context[:record]
         extension = MiniMime.lookup_by_content_type(result["mime_type"] || "")&.extension
-        result["filename"] = "#{context[:record].asset.friendlier_id}_#{context[:metadata][:kithe_derivative_key]}.#{extension}"
+        result["filename"] = "#{context[:record].asset.friendlier_id}_#{context[:kithe_derivative_key]}.#{extension}"
+        result["kithe_derivative_key"] = context[:kithe_derivative_key]
       end
 
       return result

data/lib/kithe/version.rb

@@ -1,3 +1,3 @@
 module Kithe
-  VERSION = '1.1.2'
+  VERSION = '2.0.0-alpha1'
 end

data/lib/shrine/plugins/kithe_accept_remote_url.rb

@@ -8,7 +8,19 @@ class Shrine
     # It also supports specifying custom request headers for those remote URLs, to
     # support OAuth2 Authorization headers, with browse-everything or similar.
     #
-    # It uses the shrine-url storage, registering it as storage with key "remote_url";
+    #     model.attachment_column = {
+    #       "storate" => "remote_url",
+    #       "id" => "http://example.com/image.jpg",
+    #       "headers" => {
+    #         "Authorization" => "something"
+    #       }
+    #     }
+    #
+    # If you provide the (optional) "headers" key, they will wind up stored with
+    # file data in "metadata" hash, as "remote_url_headers". And they will be
+    # used with HTTP request to fetch the URL given, when promoting.
+    #
+    # The implementation uses the shrine-url storage, registering it as storage with key "remote_url";
     # our custom kithe_multi_cache plugin to allow this alternate storage to be set as
     # cache even though it's not main cache; and a #promote override suggested by
     # Janko@shrine to get request headers to be supported.
@@ -18,14 +30,14 @@ class Shrine
     # FUTURE. Need to whitelist allowed URLs/hostnames. :( A pain cause it'll
     # be different for different apps, so we need to allow uploader customization?
     class KitheAcceptRemoteUrl
+      STORAGE_KEY = :remote_url
+      METADATA_KEY = "remote_url_headers"
+
       def self.configure(uploader, options = {})
         # Ensure remote_url is registered as a storage
-        # Note, using downloader: :net_http so it can be tested with WebMock, would be
-        # better not to have to do that.
-        # https://github.com/shrinerb/shrine-url/issues/5
         #
-        # Lazy default to make it easier to specify other.
-        uploader.storages[:remote_url] ||= Shrine::Storage::Url.new
+        # Lazy default to make it easier to specify other if an app wants to.
+        uploader.storages[STORAGE_KEY] ||= Shrine::Storage::Url.new
       end
 
       def self.load_dependencies(uploader, *)
@@ -34,17 +46,32 @@ class Shrine
         uploader.plugin :kithe_multi_cache, additional_cache: :remote_url
       end
 
+      module FileMethods
+        attr_reader :url_fetch_headers
+        def initialize(data)
+          # passed in as headers top-level key, but any but whitelisted keys actually
+          # end up being thrown out by shrine, and too hard to change that, so
+          # we'll copy it to 'metadata'
+          if data["storage"].to_s == STORAGE_KEY.to_s && data["headers"]
+            data["metadata"] ||= {}
+            data["metadata"][METADATA_KEY] = data["headers"]
+          end
+          super
+        end
+      end
+
       module AttacherMethods
+
         # Override to use 'headers' key in UploadedFile data for making remote request,
         # when remote_url is being supplied.
-        def promote(cached_file = get, **options)
-          if cached_file.storage_key.to_s == "remote_url" && cached_file.data["headers"]
+        def promote(storage: store_key, **options)
+          if file.storage_key.to_s == STORAGE_KEY.to_s && file.data.dig("metadata", METADATA_KEY)
             # instead of having Shrine "open" the file itself, we'll "open" it ourselves, so
             # we can add supplied headers. Due to the beauty of design of `down` and `shrine-url`,
             # and lazy opening, they'll end up using what we already opened. This approach
             # suggested by Janko.
             # https://groups.google.com/d/msg/ruby-shrine/SbeGujDa_k8/PeSGwpl9BAAJ
-            cached_file.open(headers: cached_file.data["headers"])
+            file.open(headers: file.data.dig("metadata", METADATA_KEY))
           end
           super
         end

data/lib/shrine/plugins/kithe_multi_cache.rb

@@ -24,20 +24,17 @@ class Shrine
     # And the data can be saved, and the remote url (shrine-url) file will be promoted as usual,
     # even though it's not registered as the cache storage.
     #
-    # NOTE: This implementation can be made a lot simpler once this PR is in a shrine release:
-    # https://github.com/shrinerb/shrine/pull/319
-    # https://github.com/shrinerb/shrine/commit/88c23d54814568b04987680f00b6b36f421c8d81
     module KitheMultiCache
       def self.configure(uploader, options = {})
-        uploader.opts[:kithe_multi_cache_keys]  = Array(options[:additional_cache]).collect(&:to_s)
+        uploader.opts[:kithe_multi_cache_keys]  = Array(options[:additional_cache]).collect(&:to_sym)
       end
 
       # override #cache to lazily extend with our custom module. Kinda hacky,
       # but couldn't think of any other way to only extend the "cache" uploader,
       # and not the "store" uploader.
       module AttacherMethods
-        def cached?(file = get)
-          super || (file && shrine_class.opts[:kithe_multi_cache_keys].include?(file.storage_key))
+        def cached?(file = self.file)
+          super || (file && shrine_class.opts[:kithe_multi_cache_keys].include?(file.storage_key.to_sym))
         end
       end
     end

data/lib/shrine/plugins/kithe_promotion_callbacks.rb

@@ -0,0 +1,82 @@
+class Shrine
+  module Plugins
+    # We want ActiveSupport-style callbacks around "promotion" -- the shrine process of finalizing
+    # a file by moving it from 'cache' storage to 'store' storage.
+    #
+    # We want to suport after_promotion hooks, and before_promotion hooks, the before_promotion hooks
+    # should be able to cancel promotion. (A convenient way to do validation even with backgrounding promotion,
+    # although you'd want to record the validation fail somewhere)
+    #
+    # For now, the actual hooks are registered in the `Asset` activerecord model. This works because
+    # our Asset model only has ONE shrine attachment, it is backwards compatible with kithe 1.
+    # It might make more sense to have the callbacks on the Uploader itself, in the future though.
+    #
+    # We want to be able to register these callbacks, and have them invoked regardless of how
+    # promotion happens -- inline; in a background job; or even explicitly calling Asset#promote
+    #
+    # ## Weird implementation
+    #
+    # It's a bit hard to get this to happen in shrine architecture. We end up needing to assume
+    # activerecord and wrap the activerecord_after_save method (for inline promotion). And then also
+    # overwrite atomic_promote to get background promotion and other cases.
+    #
+    # Because getting this right required some shuffling around of where the wrapping happened, it
+    # was convenient and avoided confusion to isolate wrapping in a class method that can be used
+    # anywhere, and only depends on args passed in, no implicit state anywhere.
+    class KithePromotionCallbacks
+      # promotion logic differs somewhat in different modes of use (bg or inline promotion),
+      # so we extract the wrapping logic here. Exactly what the logic wrapped is can
+      # differ.
+      #
+      #     Kithe::PromotionCallbacks.with_promotion_callbacks(record) do
+      #        promotion_logic # sometimes `super`
+      #     end
+      #
+      def self.with_promotion_callbacks(model)
+        # If callbacks haven't been skipped, and we have a model that implements
+        # callbacks, wrap yield in callbacks.
+        #
+        # Otherwise, just do it.
+        if (  !model.file_attacher.promotion_directives["skip_callbacks"] &&
+              model &&
+              model.class.respond_to?(:_promotion_callbacks) )
+          model.run_callbacks(:promotion) do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      module AttacherMethods
+        # For INLINE promotion, we need to wrap this one in callbacks, in order to be
+        # wrapping enough to a) be able to cancel in `before`, and b) have `after`
+        # actually be running after promotion is complete and persisted.
+        #
+        # But we only want to do it here for 'inline' promotion mode. For 'false'
+        # disabled promotion, we don't want to run callbacks at all; and for 'background'
+        # this is too early, we want callbacks to run in bg job, not here. AND only
+        # if we're actually promoting, otherwise we don't want to run callbacks!
+        def activerecord_after_save
+          if self.promotion_directives["promote"] == "inline" && promote?
+            Shrine::Plugins::KithePromotionCallbacks.with_promotion_callbacks(record) do
+              super
+            end
+          else
+            super
+          end
+        end
+
+        # Wrapping atomic_promote in callbacks gets background promotion, since the shrine pattern
+        # for background job for promotion uses atomic_promote. It also gets any 'manual' use of atomic
+        # promote, such as from our Asset#promote method.
+        def atomic_promote(*args, **kwargs)
+          Shrine::Plugins::KithePromotionCallbacks.with_promotion_callbacks(record) do
+            super
+          end
+        end
+      end
+    end
+    register_plugin(:kithe_promotion_callbacks, KithePromotionCallbacks)
+  end
+end

data/lib/shrine/plugins/kithe_promotion_directives.rb

@@ -0,0 +1,111 @@
+class Shrine
+  module Plugins
+    # This adds some features around shrine promotion that we found useful for dealing
+    # with backgrounding promotion.
+    #
+    # By default the kithe setup:
+    #
+    # * Does "promotion" in background job -- metadata extraction, and moving file from 'cache' to 'store'
+    # * Runs ActiveSupport-style callbacks around promotion (before_promotion, after_promotion)
+    # * Uses these callbacks to make sure we extract metadata on promotion (which shrine doesn't do by default)
+    # * Uses these callbacks to trigger our custom create_derivatives code *after* promotion
+    #
+    # There are times you want to customize these life cycle actions, either disabling them, or switching
+    # them from a background job to happen inline in the foreground. Some use cases for this are: 1) in
+    # automated testing; 2) when you are running a batch job (eg batch import), you might want to
+    # disable some expensive things per-record to instead do them all in batch at the end, or
+    # run them inline to keep from clogging up your bg job queue, and have better 'backpressure'.
+    #
+    # We provide something we call "promotion directives" to let you customize these. You can set
+    # them on a shrine Attacher; or on a Kithe `Asset` model individually, or globally on the class.
+    #
+    # ## Directives
+    #
+    # * `promote`: default `:background`; set to `:inline` to do promotion inline instead of a background
+    #    job, or `false` to make promotion not happen automatically at all.
+    #
+    # * `skip_callbacks`: default `false`, set to `true` to disable our custom promotion callbacks
+    #    entirely, including disabling our default callbacks such as derivative creation and
+    #    promotion metadata extraction.
+    #
+    # * `create_derivatives`: default `background` (create a separate bg job). Also can be `false`
+    #    to disable, or `inline` to create derivatives 'inline' when the after_promotion hook
+    #    occurs -- which could already be in a bg job depending on `promote` directive!
+    #
+    # * `delete`: should _deletion_ of shrine attachment happen in a bg job? Default `:background`,
+    #    can also be `false` (can't think of a good use case), or `:inline`.
+    #
+    # # Examples of setting
+    #
+    # ## Globally on Kithe::Asset
+    #
+    # Useful for batch processing or changing test defaults.
+    #
+    #    Kithe::Asset.promotion_directives = { promote: :inline, create_derivatives: false }
+    #
+    # ## On a Kithe::Asset individual model
+    #
+    #    asset = Kithe:Assst.new
+    #    asset.set_promotion_directives(create_derivatives: :inline)
+    #
+    # (Aggregates on top of whatever was set at class level of previously set with `Asset#set_promotion_directives)`,
+    # does not replace previously settings but merges into them!
+    #
+    # ## Directly on a shrine attacher
+    #
+    #   some_asset.file = some_assignable_file
+    #   some_asset.file_attacher.set_promotion_directives(skip_callbacks: true)
+    #   some_asset.save!
+    #
+    # (Aggregates on top of whatever was already set, merges into it, does not replace!)
+    #
+    # ## Checking current settings
+    #
+    #     some_asset.promotion_directives
+    #
+    # or
+    #
+    #     some_asset.file_attacher.promotion_directives
+    #
+    class KithePromotionDirectives
+      # 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]
+
+      module AttacherMethods
+
+        # Set one or more promotion directives, stored 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) - KithePromotionDirectives.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
+      end
+    end
+    register_plugin(:kithe_promotion_directives, KithePromotionDirectives)
+  end
+end