shrine 1.4.2 → 2.0.0

data/lib/shrine/plugins/direct_upload.rb

@@ -32,6 +32,9 @@ class Shrine
     #       }
     #     }
     #
+    # Note that the endpoint uploads the file standalone, without any knowledge
+    # of the record, so `context[:record]` and `context[:name]` will be nil.
+    #
     # Once you've uploaded the file, you need to assign the result to the
     # hidden attachment field in the form. There are many great JavaScript
     # libraries for file uploads, most popular being [jQuery-File-Upload].
@@ -156,18 +159,12 @@ class Shrine
         uploader.plugin :rack_file
       end
 
-      def self.configure(uploader, allowed_storages: [:cache], presign: nil, presign_options: {}, presign_location: nil, max_size: nil)
-        if presign.respond_to?(:call)
-          warn "Passing a block to :presign in direct_upload plugin is deprecated and will be removed in Shrine 2. Use :presign_options instead."
-          presign_options = presign
-          presign = true
-        end
-
-        uploader.opts[:direct_upload_allowed_storages] = allowed_storages
-        uploader.opts[:direct_upload_presign] = presign
-        uploader.opts[:direct_upload_presign_options] = presign_options
-        uploader.opts[:direct_upload_presign_location] = presign_location
-        uploader.opts[:direct_upload_max_size] = max_size
+      def self.configure(uploader, opts = {})
+        uploader.opts[:direct_upload_allowed_storages] = opts.fetch(:allowed_storages, uploader.opts.fetch(:direct_upload_allowed_storages, [:cache]))
+        uploader.opts[:direct_upload_presign] = opts.fetch(:presign, uploader.opts[:direct_upload_presign])
+        uploader.opts[:direct_upload_presign_options] = opts.fetch(:presign_options, uploader.opts.fetch(:direct_upload_presign_options, {}))
+        uploader.opts[:direct_upload_presign_location] = opts.fetch(:presign_location, uploader.opts[:direct_upload_presign_location])
+        uploader.opts[:direct_upload_max_size] = opts.fetch(:max_size, uploader.opts[:direct_upload_max_size])
 
         uploader.assign_upload_endpoint(App) unless uploader.const_defined?(:UploadEndpoint)
       end
@@ -185,12 +182,6 @@ class Shrine
           endpoint_class.opts[:shrine_class] = self
           const_set(:UploadEndpoint, endpoint_class)
         end
-
-        # Returns the Roda direct upload endpoint.
-        def direct_endpoint
-          warn "Shrine.direct_endpoint is deprecated and will be removed in Shrine 2, you should use Shrine::UploadEndpoint instead."
-          self::UploadEndpoint
-        end
       end
 
       # Routes incoming requests. It first asserts that the storage is existent
@@ -198,7 +189,6 @@ class Shrine
       # with the file upload and returns the uploaded file as JSON.
       class App < Roda
         plugin :default_headers, "Content-Type"=>"application/json"
-        plugin :json_parser
 
         route do |r|
           r.on ":storage" do |storage_key|
@@ -260,7 +250,7 @@ class Shrine
           if presign_location
             presign_location.call(request)
           else
-            SecureRandom.hex(30) + request.params["extension"].to_s
+            uploader.send(:generate_uid, nil) + request.params["extension"].to_s
           end
         end
 

data/lib/shrine/plugins/download_endpoint.rb

@@ -47,11 +47,13 @@ class Shrine
     #
     # [Roda]: https://github.com/jeremyevans/roda
     module DownloadEndpoint
-      def self.configure(uploader, storages:, prefix:, disposition: "inline", host: nil)
-        uploader.opts[:download_endpoint_storages] = storages
-        uploader.opts[:download_endpoint_prefix] = prefix
-        uploader.opts[:download_endpoint_disposition] = disposition
-        uploader.opts[:download_endpoint_host] = host
+      def self.configure(uploader, opts = {})
+        uploader.opts[:download_endpoint_storages] = opts.fetch(:storages, uploader.opts[:download_endpoint_storages])
+        uploader.opts[:download_endpoint_prefix] = opts.fetch(:prefix, uploader.opts[:download_endpoint_prefix])
+        uploader.opts[:download_endpoint_disposition] = opts.fetch(:disposition, uploader.opts.fetch(:download_endpoint_disposition, "inline"))
+        uploader.opts[:download_endpoint_host] = opts.fetch(:host, uploader.opts[:download_endpoint_host])
+
+        raise Error, "The :storages option is required for download_endpoint plugin" if uploader.opts[:download_endpoint_storages].nil?
 
         uploader.assign_download_endpoint(App) unless uploader.const_defined?(:DownloadEndpoint)
       end
@@ -84,7 +86,7 @@ class Shrine
               id,
             ].join("/")
           else
-            super(options)
+            super
           end
         end
       end
@@ -93,8 +95,6 @@ class Shrine
       # and allowed. Afterwards it proceeds with the file download using
       # streaming.
       class App < Roda
-        plugin :streaming
-
         route do |r|
           r.on ":storage" do |storage_key|
             @storage = get_storage(storage_key)
@@ -106,15 +106,18 @@ class Shrine
               response["Content-Disposition"] = "#{disposition}; filename=#{filename.inspect}"
               response["Content-Type"] = Rack::Mime.mime_type(extname)
 
-              chunks = get_stream(id)
-              _, content_length = chunks.peek
+              stream = get_stream(id)
+              _, content_length = stream.peek
               response['Content-Length'] = content_length.to_s if content_length
 
-              stream do |out|
-                chunks.each do |chunk|
-                  out << chunk
+              chunks = Enumerator.new do |y|
+                loop do
+                  chunk, * = stream.next
+                  y << chunk
                 end
               end
+
+              r.halt response.finish_with_body(chunks)
             end
           end
         end

data/lib/shrine/plugins/dynamic_storage.rb

@@ -34,20 +34,12 @@ class Shrine
         private
 
         def resolve_dynamic_storage(name)
-          dynamic_storage_cache.fetch(name) do
-            dynamic_storages.each do |regex, block|
-              if match = name.to_s.match(regex)
-                dynamic_storage_cache[name] = block.call(match)
-                break
-              end
+          dynamic_storages.each do |regex, block|
+            if match = name.to_s.match(regex)
+              return block.call(match)
             end
-
-            dynamic_storage_cache[name]
           end
-        end
-
-        def dynamic_storage_cache
-          @dynamic_storage_cache ||= {}
+          nil
         end
       end
     end

data/lib/shrine/plugins/included.rb

@@ -1,8 +1,8 @@
 class Shrine
   module Plugins
-    # The included plugin allows you to hook up to the `.included` hook when
-    # of the "attachment" module. This allows you to add additonal methods to
-    # the model whenever an attachment is included.
+    # The included plugin allows you to hook up to the `.included` hook of the
+    # attachment module, and do additional action on the model which includes
+    # it.
     #
     #     plugin :included do |name|
     #       define_method("#{name}_width") do
@@ -14,22 +14,9 @@ class Shrine
     #       end
     #     end
     #
-    # The block is evaluated in the context of the model, but note that you
-    # cannot use keywords like `def`, instead you should use the
-    # metaprogramming equivalents like `define_method`. Now when an attachment
-    # is included to a model, it will receive the appropriate methods:
-    #
-    #     class User
-    #       include ImageUploader[:avatar]
-    #     end
-    #
-    #     user = User.new
-    #     user.avatar_width  #=> nil
-    #     user.avatar_height #=> nil
-    #
-    #     user.avatar = File.open("avatar.jpg")
-    #     user.avatar_width  #=> 300
-    #     user.avatar_height #=> 500
+    # The block is evaluated in the context of the model via `instance_exec`.
+    # This means you cannot use keywords like `def`, instead you should use the
+    # metaprogramming equivalents like `define_method`.
     module Included
       def self.configure(uploader, &block)
         uploader.opts[:included_block] = block

data/lib/shrine/plugins/keep_files.rb

@@ -20,10 +20,10 @@ class Shrine
     #
     # [event store]: http://docs.geteventstore.com/introduction/event-sourcing-basics/
     module KeepFiles
-      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
+      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

data/lib/shrine/plugins/logging.rb

@@ -48,10 +48,10 @@ class Shrine
         uploader.plugin :hooks
       end
 
-      def self.configure(uploader, logger: nil, stream: $stdout, format: :human)
-        uploader.opts[:logging_logger] = logger
-        uploader.opts[:logging_stream] = stream
-        uploader.opts[:logging_format] = format
+      def self.configure(uploader, opts = {})
+        uploader.opts[:logging_logger] = opts.fetch(:logger, uploader.opts[:logging_logger])
+        uploader.opts[:logging_stream] = opts.fetch(:stream, uploader.opts.fetch(:logging_stream, $stdout))
+        uploader.opts[:logging_format] = opts.fetch(:format, uploader.opts.fetch(:logging_format, :human))
       end
 
       module ClassMethods

data/lib/shrine/plugins/migration_helpers.rb

@@ -1,57 +1,60 @@
+warn "The migration_helpers Shrine plugin is deprecated and will be removed in Shrine 3. Attacher#cached? and Attacher#stored? have been moved to base."
+
 class Shrine
   module Plugins
     # The migration_helpers plugin gives the attacher additional helper methods
     # which are convenient when doing file migrations.
     #
-    # By default additional methods are also added to the model which delegate
-    # to the underlying attacher. If you want to disable that, you can load the
-    # plugin with `delegate: false`:
-    #
-    #     plugin :migration_helpers, delegate: false
-    #
-    # ## `attachment_cache` and `attachment_store`
-    #
-    # These methods return cache and store uploaders used by the underlying
-    # attacher:
-    #
-    #     user.avatar_cache #=> #<Shrine @storage_key=:cache @storage=#<Shrine::Storage::FileSystem @directory=public/uploads>>
-    #     user.avatar_store #=> #<Shrine @storage_key=:store @storage=#<Shrine::Storage::S3:0x007fb8343397c8 @bucket=#<Aws::S3::Bucket name="foo">>>
-    #
-    #     # attacher equivalents
-    #     user.avatar_attacher.cache
-    #     user.avatar_attacher.store
+    # The plugin also allows convenient delegating to these methods through the
+    # model, by setting `:delegate`:
     #
-    # ## `attachment_cached?` and `attachment_stored?`
-    #
-    # These methods return true if attachment exists and is cached/stored:
+    #     plugin :migration_helpers, delegate: true
     #
-    #     user.avatar_cached? # user.avatar && user.avatar_cache.uploaded?(user.avatar)
-    #     user.avatar_stored? # user.avatar && user.avatar_store.uploaded?(user.avatar)
-    #
-    #     # attacher equivalents
-    #     user.avatar_attacher.cached?
-    #     user.avatar_attacher.stored?
-    #
-    # ## `update_attachment`
+    # ## `update_stored`
     #
     # This method updates the record's attachment with the result of the given
     # block.
     #
+    #     user.avatar_attacher.update_stored do |avatar|
+    #       user.avatar_attacher.store.upload(avatar) # saved to the record
+    #     end
+    #
+    #     # with model delegation
     #     user.update_avatar do |avatar|
     #       user.avatar_store.upload(avatar) # saved to the record
     #     end
     #
-    #     # attacher equivalent
-    #     user.avatar_attacher.update_stored { |avatar| }
-    #
     # The block will get triggered _only_ if the attachment is present and not
     # cached, *and* will save the record only if the record's attachment
     # hasn't changed in the time it took to execute the block. This method is
     # most useful for adding/removing versions and changing locations of files.
+    #
+    # ## `cached?` and `stored?`
+    #
+    # These methods return true if attachment exists and is cached/stored:
+    #
+    #     user.avatar_attacher.cached? # user.avatar && user.avatar_attacher.cache.uploaded?(user.avatar)
+    #     user.avatar_attacher.stored? # user.avatar && user.avatar_attacher.store.uploaded?(user.avatar)
+    #
+    #     # with model delegation
+    #     user.avatar_cached?
+    #     user.avatar_stored?
+    #
+    # ## `attachment_cache` and `attachment_store`
+    #
+    # These methods return cache and store uploaders used by the underlying
+    # attacher:
+    #
+    #     # these methods already exist without migration_helpers
+    #     user.avatar_attacher.cache #=> #<Shrine @storage_key=:cache @storage=#<Shrine::Storage::FileSystem @directory=public/uploads>>
+    #     user.avatar_attacher.store #=> #<Shrine @storage_key=:store @storage=#<Shrine::Storage::S3:0x007fb8343397c8 @bucket=#<Aws::S3::Bucket name="foo">>>
+    #
+    #     # with model delegation
+    #     user.avatar_cache
+    #     user.avatar_store
     module MigrationHelpers
-      def self.configure(uploader, options = {})
-        warn "The :delegate option in migration_helpers Shrine plugin will default to false in Shrine 2. To remove this warning, set :delegate explicitly." if !options.key?(:delegate)
-        uploader.opts[:migration_helpers_delegate] = options.fetch(:delegate, true)
+      def self.configure(uploader, delegate: false)
+        uploader.opts[:migration_helpers_delegate] = delegate
       end
 
       module AttachmentMethods

data/lib/shrine/plugins/moving.rb

@@ -1,54 +1,36 @@
 class Shrine
   module Plugins
-    # The moving plugin enables you to move files to specified storages. On
-    # the filesystem moving is istantaneous, since the OS only changes the
-    # pointer, so this plugin is useful when dealing with large files.
+    # The moving plugin makes so that when files are supposed to be uploaded,
+    # they are moved instead. For example, on FileSystem moving is
+    # instantaneous regardless of the filesize, so it's suitable for speeding
+    # up uploads for larger files.
     #
-    # This plugin is also recommended if you're doing processing, since by
-    # default temporary files won't immediately get deleted (Ruby's Tempfiles
-    # usually get deleted only when the process ends).
+    #     plugin :moving
     #
-    #     plugin :moving, storages: [:cache]
-    #
-    # The `:storages` option specifies which storages the file will be moved
-    # to. The above will move raw files to cache (without this plugin it's
-    # simply copied over). However, you may want to move cached files to
-    # `:store` as well:
-    #
-    #     plugin :moving, storages: [:cache, :store]
+    # By default files will be moved whenever the storage supports it. If you
+    # want moving to happen only for certain storages, you can set `storages`:
     #
-    # What exactly means "moving"? If both the file being uploaded and the
-    # destination are on the filesystem, a `mv` command will be executed
-    # (making the transfer instantaneous). Some other storages may implement
-    # moving as well, usually only for files which are on the same storage.
-    # If moving isn't implemented by the storage, the file will be simply
-    # deleted after upload.
+    #     plugin :moving, storages: [:cache]
     module Moving
-      def self.configure(uploader, storages:)
-        uploader.opts[:moving_storages] = storages
+      def self.configure(uploader, opts = {})
+        uploader.opts[:moving_storages] = opts.fetch(:storages, uploader.opts[:moving_storages])
       end
 
       module InstanceMethods
         private
 
-        # If the storage supports moving we use that, otherwise we do moving by
-        # copying and deleting.
+        # Moves the file if storage supports it, otherwise defaults to copying.
         def copy(io, context)
           if move?(io, context)
-            if movable?(io, context)
-              move(io, context)
-            else
-              warn "The #{storage_key.inspect} Shrine storage doesn't support moving a #{io.inspect}. It is currently still deleted, but it won't be in Shrine 2."
-              super
-              io.delete if io.respond_to?(:delete)
-            end
+            move(io, context)
           else
             super
           end
         end
 
         def move(io, context)
-          storage.move(io, context[:location], context[:metadata])
+          context[:upload_options] = (context[:upload_options] || {}).merge(shrine_metadata: context[:metadata])
+          storage.move(io, context[:location], context[:upload_options])
         end
 
         def movable?(io, context)
@@ -56,6 +38,11 @@ class Shrine
         end
 
         def move?(io, context)
+          moving_storage? && movable?(io, context)
+        end
+
+        def moving_storage?
+          opts[:moving_storages].nil? ||
           opts[:moving_storages].include?(storage_key)
         end
       end

data/lib/shrine/plugins/parallelize.rb

@@ -11,8 +11,8 @@ class Shrine
     #
     #     plugin :parallelize, threads: 5
     module Parallelize
-      def self.configure(uploader, threads: 3)
-        uploader.opts[:parallelize_threads] = threads
+      def self.configure(uploader, opts = {})
+        uploader.opts[:parallelize_threads] = opts.fetch(:threads, uploader.opts.fetch(:parallelize_threads, 3))
       end
 
       module InstanceMethods
@@ -43,8 +43,8 @@ class Shrine
         end
 
         class ThreadPool
-          def initialize(thread_count)
-            @thread_count = thread_count
+          def initialize(size)
+            @size = size
             @tasks = Queue.new
           end
 
@@ -53,7 +53,7 @@ class Shrine
           end
 
           def perform
-            threads = @thread_count.times.map { spawn_thread }
+            threads = @size.times.map { spawn_thread }
             threads.each(&:join)
           end
 

data/lib/shrine/plugins/pretty_location.rb

@@ -23,8 +23,8 @@ class Shrine
     #     plugin :pretty_location, namespace: "/"
     #     # "blog/user/.../493g82jf23.jpg"
     module PrettyLocation
-      def self.configure(uploader, namespace: nil)
-        uploader.opts[:pretty_location_namespace] = namespace
+      def self.configure(uploader, opts = {})
+        uploader.opts[:pretty_location_namespace] = opts.fetch(:namespace, uploader.opts[:pretty_location_namespace])
       end
 
       module InstanceMethods
@@ -44,10 +44,6 @@ class Shrine
 
         private
 
-        def generate_uid(io)
-          SecureRandom.hex(5)
-        end
-
         def class_location(klass)
           parts = klass.name.downcase.split("::")
           if separator = opts[:pretty_location_namespace]