shrine 2.19.4 → 3.0.0.alpha

data/lib/shrine/plugins/form_assign.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    module FormAssign
+      def self.load_dependencies(uploader)
+        uploader.plugin :entity
+      end
+
+      def self.configure(uploader, **opts)
+        uploader.opts[:form_assign] ||= { result: :params }
+        uploader.opts[:form_assign].merge!(opts)
+      end
+
+      module AttacherMethods
+        # Helper for setting the attachment from form fields. Returns normalized
+        # fields.
+        #
+        #     attacher = Shrine::Attacher.from_entity(photo, :image)
+        #
+        #     attacher.form_assign({ image: file, title: "Title" })
+        #     #=> { image: '{...}', title: "Title" }
+        #
+        #     attacher.form_assign({ image: "", image_remote_url: "...", title: "Title" })
+        #     #=> { image: '{...}', title: "Title" }
+        #
+        #     attacher.form_assign({ image: "", title: "Title" })
+        #     #=> { title: "Title" }
+        #
+        # You can also return the result in form of attributes to be used for
+        # database record creation.
+        #
+        #     attacher.form_assign({ image: file, title: "Title" }, result: :attributes)
+        #     #=> { image_data: '{...}', title: "Title" }
+        def form_assign(fields, result: shrine_class.opts[:form_assign][:result])
+          form   = create_form_object
+          fields = form_write(form, fields)
+
+          form_attach(form)
+
+          form_result(fields, result)
+        end
+
+        private
+
+        # Assigns form params to the form object using Shrine's attachment
+        # writers.
+        def form_write(form, fields)
+          result = fields.dup
+
+          fields.each do |key, value|
+            if form.respond_to?(:"#{key}=")
+              form.send(:"#{key}=", value)
+
+              result.delete(key)
+            end
+          end
+
+          result
+        end
+
+        # Attaches the file from the form object if atachment has changed.
+        def form_attach(form)
+          return unless form.send(:"#{name}_attacher").changed?
+
+          file = form.send(:"#{name}_attacher").file
+
+          if file
+            change uploaded_file(file.data) # use our UploadedFile class
+          else
+            change nil
+          end
+        end
+
+        # Adds attached file data to the fields if attachment has changed.
+        def form_result(fields, result_type)
+          return fields unless changed?
+
+          case result_type
+          when :params     then fields[name]            = file&.to_json
+          when :attributes then fields[:"#{name}_data"] = column_data
+          else
+            fail ArgumentError, "unrecognized result type: #{result_type.inspect}"
+          end
+
+          fields
+        end
+
+        # Creates a disposable form object with model plugin loaded.
+        def create_form_object
+          # load the model plugin into a disposable Shrine subclass
+          shrine_subclass = Class.new(shrine_class)
+          shrine_subclass.plugin :model
+
+          # create a model class with attachment methods
+          form_class = Struct.new(:"#{name}_data")
+          form_class.include shrine_subclass::Attachment(name)
+
+          # instantiate form object
+          form_class.new(column_data)
+        end
+      end
+    end
+
+    register_plugin(:form_assign, FormAssign)
+  end
+end

data/lib/shrine/plugins/included.rb

@@ -7,13 +7,14 @@ class Shrine
     # [doc/plugins/included.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/included.md
     module Included
       def self.configure(uploader, &block)
-        uploader.opts[:included_block] = block
+        uploader.opts[:included] ||= {}
+        uploader.opts[:included][:block] = block
       end
 
       module AttachmentMethods
-        def included(model)
+        def included(klass)
           super
-          model.instance_exec(@name, &shrine_class.opts[:included_block])
+          klass.instance_exec(@name, &shrine_class.opts[:included][:block])
         end
       end
     end

data/lib/shrine/plugins/infer_extension.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 class Shrine
   module Plugins
     # Documentation lives in [doc/plugins/infer_extension.md] on GitHub.
@@ -13,14 +15,12 @@ class Shrine
         }.inspect}"
       end
 
-      def self.configure(uploader, opts = {})
-        uploader.opts[:infer_extension] ||= { inferrer: :mime_types, force: false, log_subscriber: LOG_SUBSCRIBER }
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
+        uploader.opts[:infer_extension] ||= { inferrer: :mini_mime }
         uploader.opts[:infer_extension].merge!(opts)
 
         # instrumentation plugin integration
-        if uploader.respond_to?(:subscribe)
-          uploader.subscribe(:extension, &uploader.opts[:infer_extension][:log_subscriber])
-        end
+        uploader.subscribe(:extension, &log_subscriber) if uploader.respond_to?(:subscribe)
       end
 
       module ClassMethods
@@ -54,21 +54,14 @@ class Shrine
 
       module InstanceMethods
         def basic_location(io, metadata:)
-          location = super
-          current_extension = File.extname(location)
+          location = Pathname(super)
 
-          if current_extension.empty? || opts[:infer_extension][:force]
-            inferred_extension = infer_extension(metadata["mime_type"])
-            location = location.chomp(current_extension) << inferred_extension unless inferred_extension.empty?
+          if location.extname.empty? || opts[:infer_extension][:force]
+            inferred_extension = self.class.infer_extension(metadata["mime_type"])
+            location = location.sub_ext(inferred_extension) if inferred_extension
           end
 
-          location
-        end
-
-        private
-
-        def infer_extension(mime_type)
-          self.class.infer_extension(mime_type).to_s
+          location.to_s
         end
       end
 

data/lib/shrine/plugins/instrumentation.rb

@@ -6,21 +6,18 @@ class Shrine
     #
     # [doc/plugins/instrumentation.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/instrumentation.md
     module Instrumentation
-      EVENTS = %i[upload download exists delete metadata].freeze
+      EVENTS = %i[upload download open exists delete metadata].freeze
 
       # We use a proc in order to be able identify listeners.
       LOG_SUBSCRIBER = -> (event) { LogSubscriber.call(event) }
 
-      def self.configure(uploader, opts = {})
-        uploader.opts[:instrumentation] ||= { log_subscriber: LOG_SUBSCRIBER, log_events: EVENTS }
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
+        uploader.opts[:instrumentation] ||= { log_events: EVENTS, subscribers: {} }
         uploader.opts[:instrumentation].merge!(opts)
         uploader.opts[:instrumentation][:notifications] ||= ::ActiveSupport::Notifications
 
-        # we assign it to the top-level so that it's duplicated on subclassing
-        uploader.opts[:instrumentation_subscribers] ||= Hash.new { |h, k| h[k] = [] }
-
         uploader.opts[:instrumentation][:log_events].each do |event_name|
-          uploader.subscribe(event_name, &uploader.opts[:instrumentation][:log_subscriber])
+          uploader.subscribe(event_name, &log_subscriber)
         end
       end
 
@@ -48,12 +45,13 @@ class Shrine
         #     end
         def subscribe(event_name, &subscriber)
           return if subscriber.nil?
-          return if subscribers[event_name].include?(subscriber)
+          return if subscribers[event_name]&.include?(subscriber)
 
           notifications.subscribe("#{event_name}.shrine") do |event|
             subscriber.call(event) if event[:uploader] <= self
           end
 
+          subscribers[event_name] ||= []
           subscribers[event_name] << subscriber
         end
 
@@ -63,12 +61,8 @@ class Shrine
           Notifications.new(opts[:instrumentation][:notifications])
         end
 
-        def log_subscriber
-          opts[:instrumentation][:log_subscriber]
-        end
-
         def subscribers
-          opts[:instrumentation_subscribers]
+          opts[:instrumentation][:subscribers]
         end
       end
 
@@ -76,46 +70,49 @@ class Shrine
         private
 
         # Sends a `upload.shrine` event.
-        def copy(io, context)
+        def _upload(io, location:, metadata:, upload_options: {}, **options)
           self.class.instrument(
             :upload,
             storage: storage_key,
-            location: context[:location],
+            location: location,
             io: io,
-            upload_options: context[:upload_options] || {},
-            options: context,
+            upload_options: upload_options,
+            metadata: metadata,
+            options: options,
           ) { super }
         end
 
         # Sends a `metadata.shrine` event.
-        def get_metadata(io, context)
-          return super if io.is_a?(UploadedFile) && context[:metadata] != true || context[:metadata] == false
+        def get_metadata(io, metadata: nil, **options)
+          return super if io.is_a?(UploadedFile) && metadata != true || metadata == false
 
           self.class.instrument(
             :metadata,
             storage: storage_key,
             io: io,
-            options: context,
+            options: options,
           ) { super }
         end
       end
 
       module FileMethods
         # Sends a `download.shrine` event.
-        def open(**options)
+        def stream(destination, **options)
+          return super if opened?
+
           shrine_class.instrument(
             :download,
-            storage: storage_key.to_sym,
+            storage: storage_key,
             location: id,
             download_options: options,
-          ) { super }
+          ) { super(destination, **options, instrument: false) }
         end
 
         # Sends a `exists.shrine` event.
         def exists?
           shrine_class.instrument(
             :exists,
-            storage: storage_key.to_sym,
+            storage: storage_key,
             location: id,
           ) { super }
         end
@@ -124,10 +121,24 @@ class Shrine
         def delete
           shrine_class.instrument(
             :delete,
-            storage: storage_key.to_sym,
+            storage: storage_key,
             location: id,
           ) { super }
         end
+
+        private
+
+        # Sends an `open.shrine` event.
+        def _open(instrument: true, **options)
+          return super(**options) unless instrument
+
+          shrine_class.instrument(
+            :open,
+            storage: storage_key,
+            location: id,
+            download_options: options,
+          ) { super(**options) }
+        end
       end
 
       # Abstracts away different types of notifications objects
@@ -255,6 +266,15 @@ class Shrine
           )}"
         end
 
+        def on_open(event)
+          log "Open (#{event.duration}ms) – #{format(
+            storage:          event[:storage],
+            location:         event[:location],
+            download_options: event[:download_options],
+            uploader:         event[:uploader],
+          )}"
+        end
+
         def on_exists(event)
           log "Exists (#{event.duration}ms) – #{format(
             storage:  event[:storage],

data/lib/shrine/plugins/keep_files.rb

@@ -6,19 +6,9 @@ class Shrine
     #
     # [doc/plugins/keep_files.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/keep_files.md
     module KeepFiles
-      def self.configure(uploader, opts = {})
-        keep_files = (uploader.opts[:keep_files] ||= [])
-        opts[:destroyed] ? keep_files << :destroyed : keep_files.delete(:destroyed) if opts.key?(:destroyed)
-        opts[:replaced] ? keep_files << :replaced : keep_files.delete(:replaced) if opts.key?(:replaced)
-      end
-
       module AttacherMethods
-        def replace
-          super unless shrine_class.opts[:keep_files].include?(:replaced)
-        end
-
-        def destroy
-          super unless shrine_class.opts[:keep_files].include?(:destroyed)
+        def destroy_attached(*)
+          # don't delete files
         end
       end
     end

data/lib/shrine/plugins/metadata_attributes.rb

@@ -6,33 +6,34 @@ class Shrine
     #
     # [doc/plugins/metadata_attributes.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/metadata_attributes.md
     module MetadataAttributes
+      def self.load_dependencies(uploader, *)
+        uploader.plugin :entity
+      end
+
       def self.configure(uploader, mappings = {})
-        uploader.opts[:metadata_attributes_mappings] ||= {}
-        uploader.opts[:metadata_attributes_mappings].merge!(mappings)
+        uploader.opts[:metadata_attributes] ||= { mappings: {} }
+        uploader.opts[:metadata_attributes][:mappings].merge!(mappings)
       end
 
       module AttacherClassMethods
         def metadata_attributes(mappings)
-          shrine_class.opts[:metadata_attributes_mappings].merge!(mappings)
+          shrine_class.opts[:metadata_attributes][:mappings].merge!(mappings)
         end
       end
 
       module AttacherMethods
-        def assign(value, **options)
-          super
-          cached_file = get
+        def column_values
+          values = super
 
-          shrine_class.opts[:metadata_attributes_mappings].each do |source, destination|
-            attribute_name = destination.is_a?(Symbol) ? :"#{name}_#{destination}" : :"#{destination}"
+          shrine_class.opts[:metadata_attributes][:mappings].each do |source, destination|
+            metadata_attribute = destination.is_a?(Symbol) ? :"#{name}_#{destination}" : :"#{destination}"
 
-            next unless record.respond_to?(:"#{attribute_name}=")
+            next unless record.respond_to?(metadata_attribute)
 
-            if cached_file
-              record.send(:"#{attribute_name}=", cached_file.metadata[source.to_s])
-            else
-              record.send(:"#{attribute_name}=", nil)
-            end
+            values[metadata_attribute] = file && file.metadata[source.to_s]
           end
+
+          values
         end
       end
     end

data/lib/shrine/plugins/model.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation lives in [doc/plugins/model.md] on GitHub.
+    #
+    # [doc/plugins/model.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/model.md
+    module Model
+      def self.load_dependencies(uploader, **)
+        uploader.plugin :entity
+      end
+
+      def self.configure(uploader, **opts)
+        uploader.opts[:model] ||= { cache: true }
+        uploader.opts[:model].merge!(opts)
+      end
+
+      module AttachmentMethods
+        # Allows specifying whether the attachment should be for a model
+        # (default) or an entity.
+        #
+        #     Shrine::Attachment.new(:image)                # model (default)
+        #     Shrine::Attachment.new(:image, type: :model)  # model
+        #     Shrine::Attachment.new(:image, type: :entity) # entity
+        def initialize(name, **options)
+          super(name, type: :model, **options)
+        end
+
+        # We define the setter dynamically on inclusion to allow other plugins
+        # to still have time to override attachment type on inclusion.
+        def included(klass)
+          super
+
+          return unless options[:type] == :model
+
+          name = attachment_name
+
+          define_method :"#{name}=" do |value|
+            send(:"#{name}_attacher").model_assign(value)
+          end
+
+          define_method :initialize_copy do |other|
+            super(other)
+            instance_variable_set(:"@#{name}_attacher", instance_variable_get(:"@#{name}_attacher")&.dup)
+            self
+          end
+          private :initialize_copy
+        end
+
+        # Memoizes the attacher instance into an instance variable.
+        def attacher(record, options)
+          return super unless @options[:type] == :model
+
+          name = attachment_name
+
+          if !record.instance_variable_get(:"@#{name}_attacher") || options.any?
+            record.instance_variable_set(:"@#{name}_attacher", super)
+          else
+            record.instance_variable_get(:"@#{name}_attacher")
+          end
+        end
+      end
+
+      module AttacherClassMethods
+        # Initializes itself from a model instance and attachment name.
+        #
+        #     photo.image_data #=> "{...}" # a file is attached
+        #
+        #     attacher = Attacher.from_model(photo, :image)
+        #     attacher.file #=> #<Shrine::UploadedFile>
+        def from_model(record, name, type: :model, **options)
+          attacher = new(**options)
+          attacher.load_model(record, name, type: type)
+          attacher
+        end
+      end
+
+      module AttacherMethods
+        def initialize(model_cache: shrine_class.opts[:model][:cache], **options)
+          super(**options)
+          @model_cache = model_cache
+        end
+
+        # Saves record and name and initializes attachment from the model
+        # attribute. Called from `Attacher.from_model`.
+        def load_model(record, name, type: :model)
+          load_entity(record, name, type: type)
+        end
+
+        # Called by the attachment attribute setter on the model.
+        def model_assign(value, **options)
+          if model_cache?
+            assign(value, **options)
+          else
+            attach(value, **options)
+          end
+        end
+
+        # Writes uploaded file data into the model.
+        def set(*args)
+          result = super
+          write if model?
+          result
+        end
+
+        # Writes the attachment data into the model attribute.
+        def write
+          column_values.each do |name, value|
+            write_attribute(name, value)
+          end
+        end
+
+        private
+
+        # Writes given value into the model attribute.
+        def write_attribute(name = attribute, value)
+          record.public_send(:"#{name}=", value)
+        end
+
+        # Returns whether assigned files should be uploaded to/loaded from
+        # temporary storage.
+        def model_cache?
+          @model_cache
+        end
+
+        # Returns whether the attacher is being backed by a model instance.
+        # This allows users to still use the attacher with an entity instance
+        # or without any record instance.
+        def model?
+          type == :model
+        end
+      end
+    end
+
+    register_plugin(:model, Model)
+  end
+end