shrine 0.9.0 → 1.0.0

data/lib/shrine/plugins/hooks.rb

@@ -16,20 +16,23 @@ class Shrine
     #       end
     #     end
     #
-    # Each hook will be called with 2 arguments, `io` and `context`.  It's
-    # generally good to always call super when overriding a hook, especially if
-    # you're using inheritance with your uploaders.
+    # Each hook will be called with 2 arguments, `io` and `context`. You should
+    # always call `super` when overriding a hook, as other plugins may be using
+    # hooks internally, and without `super` they wouldn't get executed.
     #
     # Shrine calls hooks in the following order when uploading a file:
     #
-    # * `around_process`
-    #     * `before_process`
-    #     * PROCESS
-    #     * `after_process`
-    # * `around_store`
-    #     * `before_store`
-    #     * STORE
-    #     * `after_store`
+    # * `around_upload`
+    #     * `before_upload`
+    #     * `around_process`
+    #         * `before_process`
+    #         * PROCESS
+    #         * `after_process`
+    #     * `around_store`
+    #         * `before_store`
+    #         * STORE
+    #         * `after_store`
+    #     * `after_upload`
     #
     # Shrine calls hooks in the following order when deleting a file:
     #
@@ -59,6 +62,25 @@ class Shrine
     # existing keys.
     module Hooks
       module InstanceMethods
+        def upload(io, context = {})
+          result = nil
+          around_upload(io, context) { result = super }
+          result
+        end
+
+        def around_upload(*args)
+          before_upload(*args)
+          yield
+          after_upload(*args)
+        end
+
+        def before_upload(*)
+        end
+
+        def after_upload(*)
+        end
+
+
         def processed(io, context)
           result = nil
           around_process(io, context) { result = super }

data/lib/shrine/plugins/keep_files.rb

@@ -14,37 +14,22 @@ class Shrine
     # :replaced
     # :  If set to `true`, uploading a new attachment won't delete the old one.
     #
-    # :cached
-    # :  If set to `true`, cached files that are uploaded to store won't be
-    #    deleted.
-    #
     # For example, the following will keep destroyed and replaced files:
     #
     #     plugin :keep_files, destroyed: true, :replaced: true
     #
     # [event store]: http://docs.geteventstore.com/introduction/event-sourcing-basics/
     module KeepFiles
-      def self.configure(uploader, destroyed: nil, replaced: nil, cached: nil)
+      def self.configure(uploader, destroyed: nil, replaced: nil, **)
         uploader.opts[:keep_files] = []
         uploader.opts[:keep_files] << :destroyed if destroyed
         uploader.opts[:keep_files] << :replaced if replaced
-        uploader.opts[:keep_files] << :cached if cached
       end
 
-      module ClassMethods
-        def keep?(type)
-          opts[:keep_files].include?(type)
-        end
-
+      module InstanceMethods
         # We hook to the generic deleting, and check the appropriate phases.
-        def delete(io, context)
-          case context[:phase]
-          when :cached then super unless keep?(:cached)
-          when :replaced then super unless keep?(:replaced)
-          when :destroyed then super unless keep?(:destroyed)
-          else
-            super
-          end
+        def delete(io, context = {})
+          super unless opts[:keep_files].include?(context[:phase])
         end
       end
     end

data/lib/shrine/plugins/logging.rb

@@ -79,21 +79,21 @@ class Shrine
 
       module InstanceMethods
         def store(io, context = {})
-          log("store", context) { super }
+          log("store", io, context) { super }
         end
 
-        def delete(uploaded_file, context = {})
-          log("delete", context) { super }
+        def delete(io, context = {})
+          log("delete", io, context) { super }
         end
 
         private
 
         def processed(io, context = {})
-          log("process", context) { super }
+          log("process", io, context) { super }
         end
 
         # Collects the data and sends it for logging.
-        def log(action, context)
+        def log(action, io, context)
           result, duration = benchmark { yield }
 
           _log(
@@ -102,14 +102,15 @@ class Shrine
             uploader:     self.class,
             attachment:   context[:name],
             record_class: (context[:record].class if context[:record]),
-            record_id:    (context[:record].id if context[:record]),
-            files:        count(result),
+            record_id:    (context[:record].id if context[:record].respond_to?(:id)),
+            files:        count(io),
             duration:     ("%.2f" % duration).to_f,
           ) unless result.nil?
 
           result
         end
 
+        # Determines format of logging and calls appropriate method.
         def _log(data)
           message = send("_log_message_#{opts[:logging_format]}", data)
           self.class.logger.info(message)
@@ -121,7 +122,8 @@ class Shrine
           components.last << "[#{data[:phase]}]" if data[:phase]
           components << "#{data[:uploader]}"
           components.last << "[:#{data[:attachment]}]" if data[:attachment]
-          components << "#{data[:record_class]}[#{data[:record_id]}]" if data[:record_class]
+          components << "#{data[:record_class]}" if data[:record_class]
+          components.last << "[#{data[:record_id]}]" if data[:record_id]
           components << (data[:files] > 1 ? "#{data[:files]} files" : "#{data[:files]} file")
           components << "(#{data[:duration]}s)"
           components.join(" ")
@@ -139,9 +141,12 @@ class Shrine
         # hashes.
         def count(object)
           case object
-          when Hash  then object.count
-          when Array then object.inject(0) { |sum, o| sum += count(o) }
-          else            1
+          when Hash
+            object.count
+          when Array
+            object.inject(0) { |sum, o| sum += count(o) }
+          else
+            1
           end
         end
 

data/lib/shrine/plugins/migration_helpers.rb

@@ -20,9 +20,9 @@ class Shrine
     #       user.avatar_store.upload(avatar) # saved to the record
     #     end
     #
-    # This will get triggered _only_ if the attachment exists and is stored.
-    # The result can be anything that responds to `#to_json` and evaluates to
-    # uploaded files' data.
+    # This will get triggered _only_ if the attachment is not nil and is
+    # stored. The result can be anything that responds to `#to_json` and
+    # evaluates to uploaded files' data.
     module MigrationHelpers
       module AttachmentMethods
         def initialize(name)
@@ -51,7 +51,7 @@ class Shrine
           attachment = get
           return if attachment.nil? || cache.uploaded?(attachment)
           new_attachment = block.call(attachment)
-          update(new_attachment) unless changed?(get)
+          update(new_attachment) unless changed?(attachment)
         end
       end
     end

data/lib/shrine/plugins/module_include.rb

@@ -0,0 +1,46 @@
+class Shrine
+  module Plugins
+    # The module_include plugin allows you to extend Shrine's core classes for
+    # the given uploader with modules/methods.
+    #
+    #     plugin :module_include
+    #
+    # To add a module to a core class, call the appropriate method:
+    #
+    #     Shrine.attachment_module CustomAttachmentMethods
+    #     Shrine.attacher_module CustomAttacherMethods
+    #     Shrine.file_module CustomFileMethods
+    #
+    # Alternatively you can pass in a block (which internally creates a module):
+    #
+    #     Shrine.file_module do
+    #       def base64
+    #         Base64.encode64(read)
+    #       end
+    #     end
+    module ModuleInclude
+      module ClassMethods
+        def attachment_module(mod = nil, &block)
+          module_include(self::Attachment, mod, &block)
+        end
+
+        def attacher_module(mod = nil, &block)
+          module_include(self::Attacher, mod, &block)
+        end
+
+        def file_module(mod = nil, &block)
+          module_include(self::UploadedFile, mod, &block)
+        end
+
+        private
+
+        def module_include(klass, mod, &block)
+          mod ||= Module.new(&block)
+          klass.include(mod)
+        end
+      end
+    end
+
+    register_plugin(:module_include, ModuleInclude)
+  end
+end

data/lib/shrine/plugins/moving.rb

@@ -43,22 +43,11 @@ class Shrine
               super
               io.delete if io.respond_to?(:delete)
             end
-            # Promoting cached files will by default always delete the cached
-            # file. But, if moving plugin is enabled we want the cached file to
-            # be moved instead. However, there is no good way of letting the
-            # Attacher know that it shouldn't attempt to delete the file, so we
-            # make this instance variable hack.
-            io.instance_variable_set("@shrine_deleted", true)
           else
             super
           end
         end
 
-        # Don't delete the file if it has been moved.
-        def remove(io, context)
-          super unless io.instance_variable_get("@shrine_deleted")
-        end
-
         # Ask the storage if the given file is movable.
         def movable?(io, context)
           storage.respond_to?(:move) && storage.movable?(io, context[:location])

data/lib/shrine/plugins/multi_delete.rb

@@ -5,9 +5,9 @@ class Shrine
     #
     #     plugin :multi_delete
     #
-    # This plugin allows you pass an array of files to `Shrine.delete`.
+    # This plugin allows you pass an array of files to `Shrine#delete`.
     #
-    #     Shrine.delete([file1, file2, file3])
+    #     Shrine.new(:storage).delete([file1, file2, file3])
     #
     # Now if you're using Storage::S3, deleting an array of files will issue a
     # single HTTP request. Some other storages may support multi deletes as
@@ -15,15 +15,6 @@ class Shrine
     # at once.
     module MultiDelete
       module InstanceMethods
-        # This allows `Shrine.delete` to accept an array of files.
-        def uploaded?(uploaded_file)
-          if uploaded_file.is_a?(Array)
-            uploaded_file.all? { |file| super(file) }
-          else
-            super
-          end
-        end
-
         private
 
         # Adds the ability to upload multiple files, leveraging the underlying
@@ -33,7 +24,7 @@ class Shrine
             if storage.respond_to?(:multi_delete)
               storage.multi_delete(uploaded_file.map(&:id))
             else
-              uploaded_file.map { |file| super(file, context) }
+              uploaded_file.map { |file| _delete(file, context) }
             end
           else
             super

data/lib/shrine/plugins/parsed_json.rb

@@ -0,0 +1,22 @@
+class Shrine
+  module Plugins
+    # The parsed_json plugin is suitable for the case when your framework is
+    # automatically parsing JSON query parameters, allowing you to assign
+    # cached files with hashes/arrays.
+    #
+    #     plugin :parsed_json
+    module ParsedJson
+      module AttacherMethods
+        def assign(value)
+          if value.is_a?(Hash) && value.keys.any? { |key| key.is_a?(String) }
+            assign(value.to_json)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:parsed_json, ParsedJson)
+  end
+end

data/lib/shrine/plugins/rack_file.rb

@@ -0,0 +1,63 @@
+require "forwardable"
+
+class Shrine
+  module Plugins
+    # The rack_file plugin enables models to accept Rack file hashes as
+    # attachments.
+    #
+    #     rack_file #=>
+    #     # {
+    #     #   filename: "cats.png",
+    #     #   type: "image/png",
+    #     #   tempfile: #<Tempfile:/var/folders/3n/3asd/-Tmp-/RackMultipart201-1476-nfw2-0>,
+    #     #   head: "Content-Disposition: form-data; ...",
+    #     # }
+    #     user.avatar = rack_file
+    #     user.avatar.original_filename #=> "cats.png"
+    #     user.avatar.mime_type         #=> "image/png"
+    #
+    # Internally the plugin wraps the Rack file hash into an IO-like object,
+    # and this is what is passed to `Shrine#upload`.
+    #
+    #     plugin :rack_file
+    module RackFile
+      module AttacherMethods
+        # Checks whether a file is a Rack file hash, and in that case wraps the
+        # hash in an IO-like object.
+        def assign(value)
+          if value.is_a?(Hash) && value.key?(:tempfile)
+            assign(UploadedFile.new(value))
+          else
+            super
+          end
+        end
+      end
+
+      # This is used to wrap the Rack hash into an IO-like object which Shrine
+      # can upload.
+      class UploadedFile
+        attr_reader :original_filename, :content_type
+        attr_accessor :tempfile
+
+        def initialize(tempfile:, filename: nil, type: nil, **)
+          @tempfile          = tempfile
+          @original_filename = filename
+          @content_type      = type
+        end
+
+        def path
+          @tempfile.path
+        end
+
+        def to_io
+          @tempfile
+        end
+
+        extend Forwardable
+        delegate Shrine::IO_METHODS.keys => :@tempfile
+      end
+    end
+
+    register_plugin(:rack_file, RackFile)
+  end
+end

data/lib/shrine/plugins/recache.rb

@@ -23,7 +23,7 @@ class Shrine
     module Recache
       module AttacherMethods
         def save
-          if get && defined?(@old_attachment) # new file was assigned
+          if get && cache.uploaded?(get)
             _set cache!(get, phase: :recache)
           end
           super

data/lib/shrine/plugins/restore_cached.rb

@@ -21,8 +21,7 @@ class Shrine
           uploaded_file = uploaded_file(value) do |file|
             next unless cache.uploaded?(file)
             return unless file.exists?
-            uploader = shrine_class.uploader_for(file)
-            real_metadata = uploader.extract_metadata(file.to_io, context)
+            real_metadata = cache.extract_metadata(file.to_io, context)
             file.metadata.update(real_metadata)
           end
 

data/lib/shrine/plugins/sequel.rb

@@ -45,13 +45,12 @@ class Shrine
 
             def before_save
               super
-              #{name}_attacher.save
+              #{name}_attacher.save if #{name}_attacher.attached?
             end
 
             def after_commit
               super
-              #{name}_attacher.replace
-              #{name}_attacher._promote
+              #{name}_attacher.finalize if #{name}_attacher.attached?
             end
 
             def after_destroy_commit
@@ -86,6 +85,13 @@ class Shrine
           record.reload
           super
         end
+
+        # Support for Postgres JSON columns.
+        def read
+          value = super
+          value = value.to_hash if value.respond_to?(:to_hash)
+          value
+        end
       end
     end
 

data/lib/shrine/plugins/validation_helpers.rb

@@ -15,7 +15,7 @@ class Shrine
     #
     # The validation methods are instance-level, the `Attacher.validate` block
     # is evaluated in context of an instance of `Shrine::Attacher`, so you can
-    # easily to conditional validation.
+    # easily do conditional validation.
     #
     # If you would like to change default validation error messages, you can
     # pass in the `:default_messages` option to the plugin: