shrine 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a35f41e1e5941af4a9f726f6ff2057a3a65203f
-  data.tar.gz: 17d53c374878d16e8d20f5c5e6819fb90bb45888
+  metadata.gz: 24f4131513e38de7fad11e2b540643b268026427
+  data.tar.gz: daad25a613048ed9c5c66a818050dddcd007fb6f
 SHA512:
-  metadata.gz: 0ba8c4a7b7e65caa42e101a3197aa18fc9039c0b72abe82dc7d77641935ccfa5aa7f906d1ad6d1e1cad63aeb017d471d48df8646c5ead787ecea9ca2730cd2fd
-  data.tar.gz: accad9b2d8743585c20ec36dac4f9d73b664bd6ab63687caf2ceb13c1536f4b185165d74c45e79ad43a5aee08cdc251240f8bed9f6e8567a92fc505f8a917279
+  metadata.gz: 23591ec752213879f06ddd761b371276ac00c7eef5830ea2360e343044526a2717aaae540db89da61753630c4b5f3c2d8d05f79b72a266a25722a72bb4759395
+  data.tar.gz: c10ce66b0ba150e4c29678850b19154f67adac844fb7c2e3f34f5ff6d92c74901089c5f0f93b9642f736b8928f1a9ba4531a4a08d4074561138e13a74b530947

data/README.md

@@ -12,13 +12,70 @@ explains the motivation behind Shrine.
 - Bugs: [github.com/janko-m/shrine/issues](https://github.com/janko-m/shrine/issues)
 - Help & Discussion: [groups.google.com/group/ruby-shrine](https://groups.google.com/forum/#!forum/ruby-shrine)
 
-## Installation
+## Quick start
+
+Add Shrine to the Gemfile and write an initializer:
 
 ```rb
 gem "shrine"
 ```
 
-Shrine has been tested on MRI 2.1, MRI 2.2, MRI 2.3 and JRuby.
+```rb
+require "shrine"
+require "shrine/storage/file_system"
+
+Shrine.storages = {
+  cache: Shrine::Storage::FileSystem.new("public", prefix: "uploads/cache"),
+  store: Shrine::Storage::FileSystem.new("public", prefix: "uploads/store"),
+}
+
+Shrine.plugin :sequel # :activerecord
+Shrine.plugin :cached_attachment_data # for forms
+```
+
+Next write a migration to add a column which will hold attachment data, and run
+it:
+
+```rb
+Sequel.migration do                           # class AddImageDataToPhotos < ActiveRecord::Migration
+  change do                                   #   def change
+    add_column :photos, :image_data, :text    #     add_column :photos, :image_data, :text
+  end                                         #   end
+end                                           # end
+```
+
+Now you can create an uploader class for the type of files you want to upload,
+and make your model handle attachments:
+
+```rb
+class ImageUploader < Shrine
+  # plugins and uploading logic
+end
+```
+
+```rb
+class Photo < Sequel::Model # ActiveRecord::Base
+  include ImageUploader[:image]
+end
+```
+
+Finally, you can add the attachment fields to your form:
+
+```erb
+<form action="/photos" method="post" enctype="multipart/form-data">
+  <input name="photo[image]" type="hidden" value="<%= @photo.cached_image_data %>">
+  <input name="photo[image]" type="file">
+</form>
+
+<!-- Rails: -->
+
+<%= form_for @photo do |f| %>
+  <%= f.hidden_field :image, value: @photo.cached_image_data %>
+  <%= f.file_field :image %>
+<% end %>
+```
+
+----------
 
 ## Basics
 
@@ -139,19 +196,24 @@ Shrine::Attachment.new(:document)
 * `#image` – returns a `Shrine::UploadedFile` based on data from `image_data`
 * `#image_url` – calls `image.url` if attachment is present, otherwise returns nil.
 
-This is how you would typically create the form for a `@photo`:
+This is how you should create a form for a `@photo`:
 
+```rb
+Shrine.plugin :cached_attachment_data
+```
 ```erb
 <form action="/photos" method="post" enctype="multipart/form-data">
-  <input name="photo[image]" type="hidden" value="<%= @photo.image_data %>">
+  <input name="photo[image]" type="hidden" value="<%= @photo.cached_image_data %>">
   <input name="photo[image]" type="file">
 </form>
 ```
 
 The "file" field is for file upload, while the "hidden" field is to make the
-file persist in case of validation errors, and for direct uploads. This code
-works because `#image=` also accepts an already cached file via its JSON
-representation:
+file persist in case of validation errors, and for direct uploads. Note that
+the hidden field should always be *before* the file field.
+
+This code works because `#image=` also accepts an already cached file via its
+JSON representation (which is what `#cached_image_data` returns):
 
 ```rb
 photo.image = '{"id":"9jsdf02kd", "storage":"cache", "metadata": {...}}'
@@ -165,10 +227,10 @@ Sequel and ActiveRecord ORMs. It uses the `<attachment>_data` column for
 storing data for uploaded files, so you'll need to add it in a migration.
 
 ```rb
-add_column :movies, :video_data, :text # or a JSON column
+Shrine.plugin :sequel # :activerecord
 ```
 ```rb
-Shrine.plugin :sequel # or :activerecord
+add_column :movies, :video_data, :text
 ```
 ```rb
 class Movie < Sequel::Model
@@ -264,7 +326,7 @@ require "image_processing/mini_magick"
 
 class ImageUploader < Shrine
   include ImageProcessing::MiniMagick
-  plugin :versions, names: [:large, :medium, :small]
+  plugin :versions
 
   def process(io, context)
     if context[:phase] == :store
@@ -528,7 +590,7 @@ See the documentation of the plugin for more details, as well as the
 [Roda](https://github.com/janko-m/shrine-example)/[Rails](https://github.com/erikdahlstrand/shrine-rails-example)
 example app which demonstrates multiple uploads directly to S3.
 
-## Background jobs
+## Backgrounding
 
 Shrine is the first file upload library designed for backgrounding support.
 Moving phases of managing attachments to background jobs is essential for

data/doc/carrierwave.md

@@ -50,7 +50,7 @@ require "image_processing/mini_magick" # part of the "image_processing" gem
 
 class ImageUploader < Shrine
   include ImageProcessing::MiniMagick
-  plugin :versions, names: [:small, :medium, :large]
+  plugin :versions
 
   def process(io, context)
     if context[:phase] == :store

data/doc/creating_storages.md

@@ -37,11 +37,11 @@ class Shrine
         # deletes the file from the storage
       end
 
-      def url(id, options = {})
+      def url(id, **options)
         # URL to the remote file, accepts options for customizing the URL
       end
 
-      def clear!(confirm = nil)
+      def clear!
         # deletes all the files in the storage
       end
     end
@@ -49,12 +49,19 @@ class Shrine
 end
 ```
 
+## Upload
+
+The job of `Storage#upload` is to upload the given IO object to the storage.
+It's good practice to test the storage with a [fake IO] object which responds
+only to required methods. Some HTTP libraries don't support uploading non-file
+IOs, although for [Faraday] and [REST client] you can work around that.
+
 If your storage doesn't control which id the uploaded file will have, you
-can modify the `id` variable:
+can modify the `id` variable before returning:
 
 ```rb
 def upload(io, id, shrine_metadata: {}, **upload_options)
-  actual_id = do_upload(io, id, metadata)
+  # ...
   id.replace(actual_id)
 end
 ```
@@ -64,12 +71,12 @@ you can modify the metadata hash:
 
 ```rb
 def upload(io, id, shrine_metadata: {}, **upload_options)
-  additional_metadata = do_upload(io, id, metadata)
-  metadata.merge!(additional_metadata)
+  # ...
+  shrine_metadata.merge!(returned_metadata)
 end
 ```
 
-## Updating
+## Update
 
 If your storage supports updating data of existing files (e.g. some metadata),
 the convention is to create an `#update` method:
@@ -90,31 +97,7 @@ class Shrine
 end
 ```
 
-## Streaming
-
-If your storage can stream files by yielding chunks, you can add an additional
-`#stream` method (used by the `download_endpoint` plugin):
-
-```rb
-class Shrine
-  module Storage
-    class MyStorage
-      # ...
-
-      def stream(id)
-        # yields chunks of the file
-      end
-
-      # ...
-    end
-  end
-end
-```
-
-You should also yield the total filesize as the second argument, so that
-download_endpoint can set `Content-Length` before it starts streaming.
-
-## Moving
+## Move
 
 If your storage can move files, you can add 2 additional methods, and they will
 automatically get used by the `moving` plugin:
@@ -195,3 +178,7 @@ linter = Shrine::Storage::Linter.new(storage, action: :warn)
 Note that using the linter doesn't mean that you shouldn't write any manual
 tests for your storage. There will likely be some edge cases that won't be
 tested by the linter.
+
+[fake IO]: https://github.com/janko-m/shrine-cloudinary/blob/ca587c580ea0762992a2df33fd590c9a1e534905/test/test_helper.rb#L20-L27
+[REST client]: https://github.com/janko-m/shrine-cloudinary/blob/ca587c580ea0762992a2df33fd590c9a1e534905/lib/shrine/storage/cloudinary.rb#L138-L141
+[Faraday]: https://github.com/janko-m/shrine-uploadcare/blob/2038781ace0f54d82fa06cc04c4c2958919208ad/lib/shrine/storage/uploadcare.rb#L140

data/doc/paperclip.md

@@ -56,7 +56,7 @@ require "image_processing/mini_magick" # part of the "image_processing" gem
 
 class ImageUploader < Shrine
   include ImageProcessing::MiniMagick
-  plugin :versions, names: [:original, :thumb]
+  plugin :versions
 
   def process(io, context)
     if context[:phase] == :store

data/doc/refile.md

@@ -29,7 +29,7 @@ end
 
 While in Refile you configure attachments by passing options to `.attachment`,
 in Shrine you define all your uploading logic inside uploaders, and then
-generate an attacment module with that uploader which is included into the
+generate an attachment module with that uploader which is included into the
 model:
 
 ```rb

data/doc/regenerating_versions.md

@@ -15,7 +15,7 @@ versions:
 
 ```rb
 class ImageUploader < Shrine
-  plugin :versions, names: [:original, :thumb]
+  plugin :versions
 
   def process(io, context)
     case context[:phase]
@@ -75,7 +75,7 @@ update your processing code to generate it, and deploy it:
 
 ```rb
 class ImageUploader < Shrine
-  plugin :versions, names: [:small, :medium, :new] # we add the ":new" version
+  plugin :versions
 
   def process(io, context)
     case context[:phase]

data/lib/shrine.rb

@@ -19,7 +19,7 @@ class Shrine
     private
 
     def missing_methods_string
-      @missing_methods.map { |m, args| "`#{m}(#{args.join(", ")})`" }.join(", ")
+      @missing_methods.map { |m, args| "##{m}" }.join(", ")
     end
   end
 
@@ -322,8 +322,11 @@ class Shrine
 
         # Does the actual uploading, calling `#upload` on the storage.
         def copy(io, context)
-          context[:upload_options] = (context[:upload_options] || {}).merge(shrine_metadata: context[:metadata])
-          storage.upload(io, context[:location], context[:upload_options])
+          location = context[:location]
+          metadata = context[:metadata]
+          upload_options = context[:upload_options] || {}
+
+          storage.upload(io, location, shrine_metadata: metadata, **upload_options)
         ensure
           io.close rescue nil
         end
@@ -358,10 +361,7 @@ class Shrine
         # `#read`, `#eof?`, `#rewind`, `#size` and `#close`, otherwise raises
         # Shrine::InvalidFile.
         def _enforce_io(io)
-          missing_methods = IO_METHODS.reject do |m, a|
-            io.respond_to?(m) && [a.count, -1].include?(io.method(m).arity)
-          end
-
+          missing_methods = IO_METHODS.select { |m, a| !io.respond_to?(m) }
           raise InvalidFile.new(io, missing_methods) if missing_methods.any?
         end
 
@@ -469,7 +469,8 @@ class Shrine
         # Otherwise it assumes that it's an IO object and caches it.
         def assign(value)
           if value.is_a?(String)
-            assign_cached(value) unless value == "" || value == read
+            return if value == "" || value == read || !cache.uploaded?(uploaded_file(value))
+            assign_cached(uploaded_file(value))
           else
             uploaded_file = cache!(value, phase: :cache) if value
             set(uploaded_file)
@@ -593,9 +594,8 @@ class Shrine
         private
 
         # Assigns a cached file (refuses if the file is stored).
-        def assign_cached(value)
-          cached_file = uploaded_file(value)
-          set(cached_file) if cache.uploaded?(cached_file)
+        def assign_cached(cached_file)
+          set(cached_file)
         end
 
         # Sets and saves the uploaded file.
@@ -682,7 +682,7 @@ class Shrine
 
         # The filesize of the original file.
         def size
-          Integer(metadata["size"]) if metadata["size"]
+          (@io && @io.size) || (metadata["size"] && Integer(metadata["size"]))
         end
 
         # The MIME type of the original file.

data/lib/shrine/plugins/cached_attachment_data.rb

@@ -1,23 +1,19 @@
 class Shrine
   module Plugins
-    # The cached_attachment_data adds a method for assigning cached files that
-    # is more convenient for forms.
+    # The cached_attachment_data plugin adds the ability to retain the cached
+    # file across form redisplays, which means the file doesn't have to be
+    # reuploaded in case of validation errors.
     #
     #     plugin :cached_attachment_data
     #
-    # If for example your attachment is called "avatar", this plugin will add
-    # `#cached_avatar_data` and `#cached_avatar_data=` methods to your model.
-    # This allows you to write your hidden field without explicitly setting
-    # `:value`:
+    # The plugin adds `#cached_<attachment>_data` to the model, which returns
+    # the cached file as JSON, and should be used to set the value of the
+    # hidden form field:
     #
     #     <%= form_for @user do |f| %>
-    #       <%= f.hidden_field :cached_avatar_data %>
+    #       <%= f.hidden_field :avatar, value: @user.cached_avatar_data %>
     #       <%= f.field_field :avatar %>
     #     <% end %>
-    #
-    # Additionally, the hidden field will only be set when the attachment is
-    # cached (as opposed to the default where `user.avatar_data` will return
-    # both cached and stored files). This keeps Rails logs cleaner.
     module CachedAttachmentData
       module AttachmentMethods
         def initialize(*)
@@ -29,6 +25,7 @@ class Shrine
             end
 
             def cached_#{@name}_data=(value)
+              warn "Calling #cached_#{@name}_data= is deprecated and will be removed in Shrine 3. You should use the original field name: `f.hidden_field :#{@name}, value: record.cached_#{@name}_data`."
               #{@name}_attacher.assign(value)
             end
           RUBY
@@ -37,7 +34,7 @@ class Shrine
 
       module AttacherMethods
         def read_cached
-          get.to_json if get && cache.uploaded?(get)
+          get.to_json if cached? && attached?
         end
       end
     end

data/lib/shrine/plugins/determine_mime_type.rb

@@ -50,12 +50,12 @@ class Shrine
     # [mime-types]: https://github.com/mime-types/ruby-mime-types
     module DetermineMimeType
       def self.configure(uploader, opts = {})
-        uploader.opts[:mime_type_analyzer] = opts.fetch(:analyzer, :file)
+        uploader.opts[:mime_type_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:mime_type_analyzer, :file))
+        uploader.opts[:mime_type_magic_header] = opts.fetch(:magic_header, uploader.opts.fetch(:mime_type_magic_header, MAGIC_NUMBER))
       end
 
-      # How many bytes we have to read to get the magic file header which
-      # contains the MIME type of the file.
-      MAGIC_NUMBER = 1024
+      # How many bytes we need to read in order to determine the MIME type.
+      MAGIC_NUMBER = 256 * 1024
 
       module InstanceMethods
         private
@@ -83,14 +83,8 @@ class Shrine
         def _extract_mime_type_with_file(io)
           require "open3"
 
-          cmd = ["file", "--mime-type", "--brief", "--"]
-
-          if io.respond_to?(:path)
-            mime_type, * = Open3.capture2(*cmd, io.path)
-          else
-            mime_type, * = Open3.capture2(*cmd, "-", stdin_data: io.read(MAGIC_NUMBER), binmode: true)
-            io.rewind
-          end
+          mime_type, status = Open3.capture2("file", "--mime-type", "--brief", "-",
+            stdin_data: magic_header(io), binmode: true)
 
           mime_type.strip unless mime_type.empty?
         end
@@ -108,9 +102,7 @@ class Shrine
           require "filemagic"
 
           filemagic = FileMagic.new(FileMagic::MAGIC_MIME_TYPE)
-          mime_type = filemagic.buffer(io.read(MAGIC_NUMBER))
-
-          io.rewind
+          mime_type = filemagic.buffer(magic_header(io))
           filemagic.close
 
           mime_type
@@ -128,6 +120,12 @@ class Shrine
             mime_type.to_s if mime_type
           end
         end
+
+        def magic_header(io)
+          content = io.read(opts[:mime_type_magic_header])
+          io.rewind
+          content
+        end
       end
     end
 

data/lib/shrine/plugins/download_endpoint.rb

@@ -1,4 +1,5 @@
 require "roda"
+require "down"
 
 class Shrine
   module Plugins
@@ -106,15 +107,17 @@ class Shrine
               response["Content-Disposition"] = "#{disposition}; filename=#{filename.inspect}"
               response["Content-Type"] = Rack::Mime.mime_type(extname)
 
-              stream = get_stream(id)
-              _, content_length = stream.peek
-              response['Content-Length'] = content_length.to_s if content_length
+              io = get_stream_io(id)
+              response["Content-Length"] = io.size.to_s if io.size
 
               chunks = Enumerator.new do |y|
-                loop do
-                  chunk, * = stream.next
-                  y << chunk
+                if io.respond_to?(:each_chunk)
+                  io.each_chunk { |chunk| y.yield(chunk) }
+                else
+                  y.yield io.read(16*1024, buffer ||= "") until io.eof?
                 end
+                io.close
+                io.delete if io.class.name == "Tempfile"
               end
 
               r.halt response.finish_with_body(chunks)
@@ -131,17 +134,14 @@ class Shrine
           shrine_class.find_storage(storage_key)
         end
 
-        def get_stream(id)
+        def get_stream_io(id)
           if storage.respond_to?(:stream)
-            storage.enum_for(:stream, id)
+            warn "Storage#stream is deprecated, in Shrine 3 the download_endpoint plugin will use only Storage#open. You should update your storage library."
+            stream = storage.enum_for(:stream, id)
+            chunks = Enumerator.new { |y| y << Array(stream.next)[0] }
+            Down::ChunkedIO.new(size: Array(stream.peek)[1], chunks: chunks)
           else
-            Enumerator.new do |y|
-              io = storage.open(id)
-              buffer = ""
-              y.yield(io.read(16*1024, buffer), io.size) until io.eof?
-              io.close
-              io.delete if io.class.name == "Tempfile"
-            end
+            storage.open(id)
           end
         end
 

data/lib/shrine/plugins/included.rb

@@ -1,16 +1,12 @@
 class Shrine
   module Plugins
     # 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
+    # attachment module, and call additional methods on the model which includes
     # it.
     #
     #     plugin :included do |name|
-    #       define_method("#{name}_width") do
-    #         send(name).width if send(name)
-    #       end
-    #
-    #       define_method("#{name}_height") do
-    #         send(name).height if send(name)
+    #       before_save do
+    #         # ...
     #       end
     #     end
     #

data/lib/shrine/plugins/logging.rb

@@ -82,20 +82,20 @@ class Shrine
       end
 
       module InstanceMethods
-        def around_process(io, context)
-          log("process", io, context) { super }
-        end
-
-        def around_store(io, context)
+        def store(io, context = {})
           log("store", io, context) { super }
         end
 
-        def around_delete(io, context)
+        def delete(io, context = {})
           log("delete", io, context) { super }
         end
 
         private
 
+        def processed(io, context = {})
+          log("process", io, context) { super }
+        end
+
         # Collects the data and sends it for logging.
         def log(action, input, context)
           result, duration = benchmark { yield }

data/lib/shrine/plugins/module_include.rb

@@ -7,17 +7,30 @@ class Shrine
     #
     # To add a module to a core class, call the appropriate method:
     #
-    #     Shrine.attachment_module CustomAttachmentMethods
-    #     Shrine.attacher_module CustomAttacherMethods
-    #     Shrine.file_module CustomFileMethods
+    #     attachment_module CustomAttachmentMethods
+    #     attacher_module CustomAttacherMethods
+    #     file_module CustomFileMethods
     #
     # Alternatively you can pass in a block (which internally creates a module):
     #
-    #     Shrine.file_module do
-    #       def base64
-    #         Base64.encode64(read)
+    #     attachment_module do
+    #       def included(model)
+    #         super
+    #
+    #         module_eval <<-RUBY, __FILE__, __LINE + 1
+    #           def #{@name}_size(version)
+    #             if #{@name}.is_a?(Hash)
+    #               #{@name}[version].size
+    #             else
+    #               #{@name}.size if #{@name}
+    #             end
+    #           end
+    #         RUBY
     #       end
     #     end
+    #
+    # The above defines an additional `#<attachment>_size` method on the
+    # attachment module, which is what is included in your model.
     module ModuleInclude
       module ClassMethods
         def attachment_module(mod = nil, &block)

data/lib/shrine/plugins/moving.rb

@@ -29,8 +29,11 @@ class Shrine
         end
 
         def move(io, context)
-          context[:upload_options] = (context[:upload_options] || {}).merge(shrine_metadata: context[:metadata])
-          storage.move(io, context[:location], context[:upload_options])
+          location = context[:location]
+          metadata = context[:metadata]
+          upload_options = context[:upload_options] || {}
+
+          storage.move(io, location, shrine_metadata: metadata, **upload_options)
         end
 
         def movable?(io, context)

data/lib/shrine/plugins/parallelize.rb

@@ -15,13 +15,17 @@ class Shrine
         uploader.opts[:parallelize_threads] = opts.fetch(:threads, uploader.opts.fetch(:parallelize_threads, 3))
       end
 
+      def self.load_dependencies(uploader, opts = {})
+        uploader.plugin :hooks
+      end
+
       module InstanceMethods
-        def store(io, context = {})
-          with_pool { |pool| super(io, thread_pool: pool, **context) }
+        def around_store(io, context)
+          with_pool { |pool| super(io, context.update(thread_pool: pool)) }
         end
 
-        def delete(uploaded_file, context = {})
-          with_pool { |pool| super(uploaded_file, thread_pool: pool, **context) }
+        def around_delete(uploaded_file, context)
+          with_pool { |pool| super(uploaded_file, context.update(thread_pool: pool)) }
         end
 
         private
@@ -41,31 +45,31 @@ class Shrine
           pool.perform
           result
         end
+      end
 
-        class ThreadPool
-          def initialize(size)
-            @size = size
-            @tasks = Queue.new
-          end
+      class ThreadPool
+        def initialize(size)
+          @size = size
+          @tasks = Queue.new
+        end
 
-          def enqueue(&task)
-            @tasks.enq(task)
-          end
+        def enqueue(&task)
+          @tasks.enq(task)
+        end
 
-          def perform
-            threads = @size.times.map { spawn_thread }
-            threads.each(&:join)
-          end
+        def perform
+          threads = @size.times.map { spawn_thread }
+          threads.each(&:join)
+        end
 
-          private
+        private
 
-          def spawn_thread
-            Thread.new do
-              Thread.current.abort_on_exception = true
-              loop do
-                task = @tasks.deq(true) rescue break
-                task.call
-              end
+        def spawn_thread
+          Thread.new do
+            Thread.current.abort_on_exception = true
+            loop do
+              task = @tasks.deq(true) rescue break
+              task.call
             end
           end
         end

data/lib/shrine/plugins/restore_cached_data.rb

@@ -10,12 +10,12 @@ class Shrine
       module AttacherMethods
         private
 
-        def assign_cached(value)
-          cached_file = uploaded_file(value) do |cached_file|
-            next unless cache.uploaded?(cached_file)
-            real_metadata = cache.extract_metadata(cached_file.to_io, context)
-            cached_file.metadata.update(real_metadata)
-            cached_file.close
+        def assign_cached(cached_file)
+          uploaded_file(cached_file) do |file|
+            file.to_io # open
+            real_metadata = cache.extract_metadata(file, context)
+            file.metadata.update(real_metadata)
+            file.close
           end
 
           super(cached_file)

data/lib/shrine/plugins/versions.rb

@@ -9,7 +9,7 @@ class Shrine
     #
     #     class ImageUploader < Shrine
     #       include ImageProcessing::MiniMagick
-    #       plugin :versions, names: [:large, :medium, :small]
+    #       plugin :versions
     #
     #       def process(io, context)
     #         if context[:phase] == :store
@@ -77,9 +77,7 @@ class Shrine
     # If you already have some versions processed in the foreground when a
     # background job is kicked off, you can setup explicit URL fallbacks:
     #
-    #     plugin :versions,
-    #       names: [:thumb, :thumb_2x, :large, :large_2x],
-    #       fallbacks: {:thumb_2x => :thumb, :large_2x => :large}
+    #     plugin :versions, fallbacks: {:thumb_2x => :thumb, :large_2x => :large}
     #
     #     # ... (background job is kicked off)
     #
@@ -112,14 +110,15 @@ class Shrine
       end
 
       def self.configure(uploader, opts = {})
+        warn "The versions Shrine plugin doesn't need the :names option anymore, you can safely remove it." if opts.key?(:names)
+
         uploader.opts[:version_names] = opts.fetch(:names, uploader.opts[:version_names])
         uploader.opts[:version_fallbacks] = opts.fetch(:fallbacks, uploader.opts.fetch(:version_fallbacks, {}))
-
-        raise Error, "The :names option is required for versions plugin" if uploader.opts[:version_names].nil?
       end
 
       module ClassMethods
         def version_names
+          warn "Shrine.version_names is deprecated and will be removed in Shrine 3."
           opts[:version_names]
         end
 
@@ -129,14 +128,14 @@ class Shrine
 
         # Checks that the identifier is a registered version.
         def version?(name)
-          version_names.map(&:to_s).include?(name.to_s)
+          warn "Shrine.version? is deprecated and will be removed in Shrine 3."
+          version_names.nil? || version_names.map(&:to_s).include?(name.to_s)
         end
 
         # Converts a hash of data into a hash of versions.
         def uploaded_file(object, &block)
           if (hash = object).is_a?(Hash) && !hash.key?("storage")
             hash.inject({}) do |result, (name, data)|
-              next result if !version?(name)
               result.update(name.to_sym => uploaded_file(data, &block))
             end
           else
@@ -165,7 +164,6 @@ class Shrine
           if (hash = io).is_a?(Hash)
             raise Error, ":location is not applicable to versions" if context.key?(:location)
             hash.inject({}) do |result, (name, version)|
-              raise Error, "unknown version: #{name.inspect}" if !self.class.version?(name)
               result.update(name => _store(version, version: name, **context))
             end
           else
@@ -190,7 +188,6 @@ class Shrine
         def url(version = nil, **options)
           if get.is_a?(Hash)
             if version
-              raise Error, "unknown version: #{version.inspect}" if !shrine_class.version?(version)
               if file = get[version]
                 file.url(**options)
               elsif fallback = shrine_class.version_fallbacks[version]
@@ -209,6 +206,14 @@ class Shrine
             end
           end
         end
+
+        private
+
+        def assign_cached(value)
+          cached_file = uploaded_file(value)
+          warn "Generating versions in the :cache phase is deprecated and will be forbidden in Shrine 3." if cached_file.is_a?(Hash)
+          super(cached_file)
+        end
       end
     end
 

data/lib/shrine/storage/linter.rb

@@ -40,7 +40,6 @@ class Shrine
         lint_read(id)
         lint_exists(id)
         lint_url(id)
-        lint_stream(id) if storage.respond_to?(:stream)
         lint_delete(id)
 
         if storage.respond_to?(:move)
@@ -67,6 +66,7 @@ class Shrine
         opened = storage.open(id)
         error :open, "doesn't return a valid IO object" if !io?(opened)
         error :open, "returns an empty IO object" if opened.read.empty?
+        opened.close
       end
 
       def lint_read(id)
@@ -85,20 +85,6 @@ class Shrine
         error :url, "should return either nil or a string" if !(url.nil? || url.is_a?(String))
       end
 
-      def lint_stream(id)
-        streamed = storage.enum_for(:stream, id).to_a
-        chunks = streamed.map { |(chunk, _)| chunk }
-        content_length = Array(streamed[0])[1]
-
-        error :stream, "doesn't yield any chunks" if chunks.empty?
-        error :stream, "yielded chunks sum up to empty content" if chunks.inject("", :+).empty?
-
-        if Array(streamed.first).size == 2
-          error :stream, "yielded content length isn't a number" if !content_length.is_a?(Integer)
-          error :stream, "yielded chunks don't sum up to given content length" if content_length != chunks.inject("", :+).length
-        end
-      end
-
       def lint_delete(id)
         storage.delete(id)
         error :delete, "file still #exists? after deleting" if storage.exists?(id)

data/lib/shrine/storage/s3.rb

@@ -75,7 +75,7 @@ class Shrine
     # [presigning]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#presigned_post-instance_method
     # [aws-sdk]: https://github.com/aws/aws-sdk-ruby
     class S3
-      attr_reader :prefix, :bucket, :s3, :host, :upload_options
+      attr_reader :s3, :bucket, :prefix, :host, :upload_options
 
       # Initializes a storage for uploading to S3.
       #
@@ -133,15 +133,9 @@ class Shrine
         Down.download(url(id), ssl_ca_cert: Aws.config[:ssl_ca_bundle])
       end
 
-      # Streams the object from S3, yielding downloaded chunks.
-      def stream(id)
-        object = object(id)
-        object.get { |chunk| yield chunk, object.content_length }
-      end
-
       # Alias for #download.
       def open(id)
-        download(id)
+        Down.open(url(id), ssl_ca_cert: Aws.config[:ssl_ca_bundle])
       end
 
       # Returns the contents of the file as a String.
@@ -218,6 +212,17 @@ class Shrine
         object(id).presigned_post(options)
       end
 
+      # Catches the deprecated `#stream` method.
+      def method_missing(name, *args)
+        if name == :stream
+          warn "Shrine::Storage::S3#stream is deprecated over calling #each_chunk on S3#open."
+          object = object(*args)
+          object.get { |chunk| yield chunk, object.content_length }
+        else
+          super
+        end
+      end
+
       protected
 
       # Returns the S3 object.

data/lib/shrine/version.rb

@@ -5,8 +5,8 @@ class Shrine
 
   module VERSION
     MAJOR = 2
-    MINOR = 0
-    TINY  = 1
+    MINOR = 1
+    TINY  = 0
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')

data/shrine.gemspec

@@ -25,7 +25,7 @@ column, and tying them to record's lifecycle.
   gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "shrine.gemspec", "doc/*.md"]
   gem.require_path = "lib"
 
-  gem.add_dependency "down", ">= 2.2.0"
+  gem.add_dependency "down", ">= 2.3.3"
 
   gem.add_development_dependency "rake", "~> 11.1"
   gem.add_development_dependency "minitest", "~> 5.8"
@@ -34,13 +34,13 @@ column, and tying them to record's lifecycle.
   gem.add_development_dependency "webmock"
   gem.add_development_dependency "rack-test_app"
   gem.add_development_dependency "dotenv"
-  gem.add_development_dependency "shrine-memory", "~> 0.2.0"
+  gem.add_development_dependency "shrine-memory", ">= 0.2.1"
 
   gem.add_development_dependency "roda"
   gem.add_development_dependency "mimemagic"
   gem.add_development_dependency "mime-types"
   gem.add_development_dependency "fastimage"
-  gem.add_development_dependency "aws-sdk", "~> 2.1.30"
+  gem.add_development_dependency "aws-sdk"
 
   unless RUBY_ENGINE == "jruby" || ENV["CI"]
     gem.add_development_dependency "ruby-filemagic", "~> 0.7"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shrine
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-30 00:00:00.000000000 Z
+date: 2016-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.3.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -126,16 +126,16 @@ dependencies:
   name: shrine-memory
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: roda
   requirement: !ruby/object:Gem::Requirement
@@ -196,16 +196,16 @@ dependencies:
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.30
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.30
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-filemagic
   requirement: !ruby/object:Gem::Requirement