shrine 2.13.0 → 2.14.0

data/lib/shrine/plugins/activerecord.rb

@@ -94,29 +94,31 @@ class Shrine
 
           return unless model < ::ActiveRecord::Base
 
-          opts = shrine_class.opts
+          name = attachment_name
 
-          model.class_eval <<-RUBY, __FILE__, __LINE__ + 1 if opts[:activerecord_validations]
-            validate do
-              #{@name}_attacher.errors.each do |message|
-                errors.add(:#{@name}, *message)
+          if shrine_class.opts[:activerecord_validations]
+            model.validate do
+              send("#{name}_attacher").errors.each do |message|
+                errors.add(name, *message)
               end
             end
-          RUBY
+          end
 
-          model.class_eval <<-RUBY, __FILE__, __LINE__ + 1 if opts[:activerecord_callbacks]
-            before_save do
-              #{@name}_attacher.save if #{@name}_attacher.changed?
+          if shrine_class.opts[:activerecord_callbacks]
+            model.before_save do
+              attacher = send("#{name}_attacher")
+              attacher.save if attacher.changed?
             end
 
-            after_commit on: [:create, :update] do
-              #{@name}_attacher.finalize if #{@name}_attacher.changed?
+            model.after_commit on: [:create, :update] do
+              attacher = send("#{name}_attacher")
+              attacher.finalize if attacher.changed?
             end
 
-            after_commit on: [:destroy] do
-              #{@name}_attacher.destroy
+            model.after_commit on: [:destroy] do
+              send("#{name}_attacher").destroy
             end
-          RUBY
+          end
         end
       end
 

data/lib/shrine/plugins/add_metadata.rb

@@ -56,19 +56,42 @@ class Shrine
     #         "resolution" => movie.resolution,
     #         "frame_rate" => movie.frame_rate }
     #     end
+    #
+    # Any previously extracted metadata can be accessed via
+    # `context[:metadata]`:
+    #
+    #     add_metadata :foo do |io, context|
+    #       context[:metadata] #=>
+    #       # {
+    #       #   "size"      => 239823,
+    #       #   "filename"  => "nature.jpg",
+    #       #   "mime_type" => "image/jpeg"
+    #       # }
+    #
+    #       "foo"
+    #     end
+    #
+    #     add_metadata :bar do |io, context|
+    #       context[:metadata] #=>
+    #       # {
+    #       #   "size"      => 239823,
+    #       #   "filename"  => "nature.jpg",
+    #       #   "mime_type" => "image/jpeg",
+    #       #   "foo"       => "foo"
+    #       # }
+    #
+    #       "bar"
+    #     end
     module AddMetadata
       def self.configure(uploader)
-        uploader.opts[:metadata] = []
+        uploader.opts[:metadata] ||= []
       end
 
       module ClassMethods
-        def add_metadata(name = nil, &block)
-          if name
-            opts[:metadata] << _metadata_proc(name, &block)
-            metadata_method(name)
-          else
-            opts[:metadata] << block
-          end
+        def add_metadata(name = nil, **options, &block)
+          opts[:metadata] << [name, options, block]
+
+          metadata_method(name) if name
         end
 
         def metadata_method(*names)
@@ -82,30 +105,41 @@ class Shrine
             metadata[name.to_s]
           end
         end
-
-        def _metadata_proc(name, &block)
-          proc do |io, context|
-            value = instance_exec(io, context, &block)
-            {name.to_s => value} unless value.nil?
-          end
-        end
       end
 
       module InstanceMethods
-        def extract_metadata(io, context)
+        def extract_metadata(io, context = {})
           metadata = super
+          context  = context.merge(metadata: metadata)
+
+          extract_custom_metadata(io, context)
+
+          metadata
+        end
+
+        private
+
+        def extract_custom_metadata(io, context)
+          opts[:metadata].each do |name, options, block|
+            result   = instance_exec(io, context, &block)
+            metadata = {}
+
+            if name
+              metadata[name.to_s] = result
+            else
+              metadata.merge!(result) if result
+            end
 
-          opts[:metadata].each do |metadata_block|
-            custom_metadata = instance_exec(io, context, &metadata_block) || {}
-            io.rewind
             # convert symbol keys to strings
-            custom_metadata.keys.each do |key|
-              custom_metadata[key.to_s] = custom_metadata.delete(key) if key.is_a?(Symbol)
+            metadata.keys.each do |key|
+              metadata[key.to_s] = metadata.delete(key) if key.is_a?(Symbol)
             end
-            metadata.merge!(custom_metadata)
-          end
 
-          metadata
+            context[:metadata].merge!(metadata)
+
+            # rewind between metadata blocks
+            io.rewind
+          end
         end
       end
     end

data/lib/shrine/plugins/backgrounding.rb

@@ -265,7 +265,12 @@ class Shrine
         def swap(new_file)
           if self.class.respond_to?(:find_record)
             reloaded = self.class.find_record(record.class, record.id)
-            return if reloaded.nil? || self.class.new(reloaded, name).read != read
+            return if reloaded.nil?
+
+            attacher   = reloaded.send(:"#{name}_attacher") if reloaded.respond_to?(:"#{name}_attacher")
+            attacher ||= self.class.new(reloaded, name) # Shrine::Attachment is not used
+
+            return if attacher.get != self.get
           end
           super
         end

data/lib/shrine/plugins/cached_attachment_data.rb

@@ -22,16 +22,16 @@ class Shrine
         def initialize(*)
           super
 
-          module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def cached_#{@name}_data
-              #{@name}_attacher.read_cached
-            end
+          name = attachment_name
 
-            def cached_#{@name}_data=(value)
-              Shrine.deprecation("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
+          define_method :"cached_#{name}_data" do
+            send(:"#{name}_attacher").read_cached
+          end
+
+          define_method :"cached_#{name}_data=" do |value|
+            Shrine.deprecation("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`.")
+            send(:"#{name}_attacher").assign(value)
+          end
         end
       end
 

data/lib/shrine/plugins/copy.rb

@@ -21,14 +21,18 @@ class Shrine
         def initialize(*)
           super
 
-          module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def initialize_copy(record)
-              super
-              @#{@name}_attacher = nil # reload the attacher
-              #{@name}_attacher.send(:write, nil) # remove original attachment
-              #{@name}_attacher.copy(record.#{@name}_attacher)
-            end
-          RUBY
+          name = attachment_name
+
+          define_method :initialize_copy do |record|
+            super(record)
+            instance_variable_set(:"@#{name}_attacher", nil) # reload the attacher
+            attacher = send(:"#{name}_attacher")
+            attacher.send(:write, nil) # remove original attachment
+            attacher.copy(record.public_send(:"#{name}_attacher"))
+          end
+
+          # Fix for JRuby
+          private :initialize_copy
         end
       end
 

data/lib/shrine/plugins/data_uri.rb

@@ -54,6 +54,7 @@ class Shrine
     #     io = Shrine.data_uri("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA")
     #     io.content_type #=> "image/png"
     #     io.size         #=> 21
+    #     io.read         # decoded content
     #
     # When the content type is ommited, `text/plain` is assumed. The parser
     # also supports raw data URIs which aren't base64-encoded.
@@ -64,6 +65,11 @@ class Shrine
     #     io.size         #=> 11
     #     io.read         #=> "raw content"
     #
+    # You can also assign a filename:
+    #
+    #     io = Shrine.data_uri("data:,content", filename: "foo.txt")
+    #     io.original_filename #=> "foo.txt"
+    #
     # ## `UploadedFile#data_uri` and `UploadedFile#base64`
     #
     # This plugin also adds UploadedFile#data_uri method, which returns a
@@ -94,15 +100,17 @@ class Shrine
       module ClassMethods
         # Parses the given data URI and creates an IO object from it.
         #
-        #     Shrine.data_uri("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA")
-        #     #=> #<Shrine::Plugins::DataUri::DataFile>
-        def data_uri(uri)
+        #     io = Shrine.data_uri("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA")
+        #     io #=> #<Shrine::Plugins::DataUri::DataFile>
+        #     io.content_type #=> "image/png"
+        #     io.size         #=> 21
+        #     io.read         # decoded content
+        def data_uri(uri, filename: nil)
           info = parse_data_uri(uri)
 
           content_type = info[:content_type] || DEFAULT_CONTENT_TYPE
           content      = info[:base64] ? Base64.decode64(info[:data]) : CGI.unescape(info[:data])
-          filename     = opts[:data_uri_filename]
-          filename     = filename.call(content_type) if filename
+          filename     = opts[:data_uri_filename].call(content_type) if opts[:data_uri_filename]
 
           data_file = DataFile.new(content, content_type: content_type, filename: filename)
           info[:data].clear
@@ -118,14 +126,9 @@ class Shrine
           media_type = scanner.scan(MEDIA_TYPE_REGEXP)
           base64 = scanner.scan(BASE64_REGEXP)
           scanner.scan(CONTENT_SEPARATOR) or raise ParseError, "data URI has invalid format"
+          content = scanner.post_match
 
-          content_type = media_type[/^[^;]+/] if media_type
-
-          {
-            content_type: content_type,
-            base64:       !!base64,
-            data:         scanner.post_match,
-          }
+          { content_type: media_type, base64: !!base64, data: content }
         end
       end
 
@@ -133,15 +136,15 @@ class Shrine
         def initialize(*)
           super
 
-          module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{@name}_data_uri=(uri)
-              #{@name}_attacher.data_uri = uri
-            end
+          name = attachment_name
+
+          define_method :"#{name}_data_uri=" do |uri|
+            send(:"#{name}_attacher").data_uri = uri
+          end
 
-            def #{@name}_data_uri
-              #{@name}_attacher.data_uri
-            end
-          RUBY
+          define_method :"#{name}_data_uri" do
+            send(:"#{name}_attacher").data_uri
+          end
         end
       end
 

data/lib/shrine/plugins/default_url_options.rb

@@ -5,14 +5,14 @@ class Shrine
     # The `default_url_options` plugin allows you to specify URL options that
     # will be applied by default for uploaded files of specified storages.
     #
-    #     plugin :default_url_options, store: {download: true}
+    #     plugin :default_url_options, store: { download: true }
     #
     # You can also generate the default URL options dynamically by using a
     # block, which will receive the UploadedFile object along with any options
     # that were passed to `UploadedFile#url`.
     #
-    #     plugin :default_url_options, store: ->(io, **options) do
-    #       {response_content_disposition: "attachment; filename=\"#{io.original_filename}\""}
+    #     plugin :default_url_options, store: -> (io, **options) do
+    #       { response_content_disposition: ContentDisposition.attachment(io.original_filename) }
     #     end
     #
     # In both cases the default options are merged with options passed to
@@ -20,7 +20,8 @@ class Shrine
     # default options.
     module DefaultUrlOptions
       def self.configure(uploader, options = {})
-        uploader.opts[:default_url_options] = (uploader.opts[:default_url_options] || {}).merge(options)
+        uploader.opts[:default_url_options] ||= {}
+        uploader.opts[:default_url_options].merge!(options)
       end
 
       module FileMethods

data/lib/shrine/plugins/determine_mime_type.rb

@@ -51,10 +51,10 @@ class Shrine
     #   extension. Note that unlike other solutions, this analyzer is not
     #   guaranteed to return the actual MIME type of the file.
     #
-    # :default
-    # : Uses the default way of extracting the MIME type, and that is reading
-    #   the `#content_type` attribute of the IO object, which might not hold
-    #   the actual MIME type of the file.
+    # :content_type
+    # : Retrieves the value of the `#content_type` attribute of the IO object.
+    #   Note that this value normally comes from the "Content-Type" request
+    #   header, so it's not guaranteed to hold the actual MIME type of the file.
     #
     # A single analyzer is not going to properly recognize all types of files,
     # so you can build your own custom analyzer for your requirements, where
@@ -88,6 +88,11 @@ class Shrine
     # [fastimage]: https://github.com/sdsykes/fastimage
     module DetermineMimeType
       def self.configure(uploader, opts = {})
+        if opts[:analyzer] == :default
+          Shrine.deprecation("The :default analyzer of the determine_mime_type plugin has been renamed to :content_type. The :default alias will not be supported in Shrine 3.")
+          opts = opts.merge(analyzer: :content_type)
+        end
+
         uploader.opts[:mime_type_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:mime_type_analyzer, :file))
       end
 
@@ -95,16 +100,12 @@ class Shrine
         # Determines the MIME type of the IO object by calling the specified
         # analyzer.
         def determine_mime_type(io)
-          if opts[:mime_type_analyzer] == :default
-            mime_type = io.content_type if io.respond_to?(:content_type)
-          else
-            analyzer = opts[:mime_type_analyzer]
-            analyzer = mime_type_analyzer(analyzer) if analyzer.is_a?(Symbol)
-            args     = [io, mime_type_analyzers].take(analyzer.arity.abs)
-
-            mime_type = analyzer.call(*args)
-            io.rewind
-          end
+          analyzer = opts[:mime_type_analyzer]
+          analyzer = mime_type_analyzer(analyzer) if analyzer.is_a?(Symbol)
+          args     = [io, mime_type_analyzers].take(analyzer.arity.abs)
+
+          mime_type = analyzer.call(*args)
+          io.rewind
 
           mime_type
         end
@@ -127,15 +128,9 @@ class Shrine
       module InstanceMethods
         private
 
-        # Calls default behaviour when :default analyzer was specified, which
-        # just reads the `#content_type` attribute, otherwise uses the specified
-        # MIME type analyzer.
+        # Calls the configured MIME type analyzer.
         def extract_mime_type(io)
-          if opts[:mime_type_analyzer] == :default
-            super
-          else
-            self.class.determine_mime_type(io)
-          end
+          self.class.determine_mime_type(io)
         end
 
         # Returns a hash of built-in MIME type analyzers.
@@ -145,7 +140,7 @@ class Shrine
       end
 
       class MimeTypeAnalyzer
-        SUPPORTED_TOOLS = [:fastimage, :file, :filemagic, :mimemagic, :marcel, :mime_types, :mini_mime]
+        SUPPORTED_TOOLS = [:fastimage, :file, :filemagic, :mimemagic, :marcel, :mime_types, :mini_mime, :content_type]
         MAGIC_NUMBER    = 256 * 1024
 
         def initialize(tool)
@@ -242,6 +237,12 @@ class Shrine
           end
         end
 
+        def extract_with_content_type(io)
+          if io.respond_to?(:content_type) && io.content_type
+            io.content_type.split(";").first
+          end
+        end
+
         def extract_filename(io)
           if io.respond_to?(:original_filename)
             io.original_filename

data/lib/shrine/plugins/download_endpoint.rb

@@ -2,9 +2,6 @@
 
 require "roda"
 
-require "base64"
-require "json"
-
 class Shrine
   module Plugins
     # The `download_endpoint` plugin provides a Rack endpoint for downloading
@@ -41,15 +38,26 @@ class Shrine
     # Links to the download endpoint are generated by calling
     # `UploadedFile#download_url` instead of the usual `UploadedFile#url`.
     #
-    #     uploaded_file.download_url #=> "/attachments/eyJpZCI6ImFkdzlyeTM5ODJpandoYWla"
+    #     uploaded_file.download_url #=> "/attachments/eyJpZCI6ImFkdzlyeTM..."
+    #
+    # ## Host
+    #
+    # You can specify download URL host via the `:host` plugin option:
+    #
+    #     plugin :download_endpoint, host: "http://example.com"
+    #
+    # or by passing `:host` to `UploadedFile#download_url`:
     #
-    # Note that streaming the file through your app might impact the request
-    # throughput of your app, depending on which web server is used. It's
-    # recommended to either configure a CDN to serve these files:
+    #     uploaded_file.download_url(host: "http://example.com")
+    #     #=> "http//example.com/attachments/eyJpZCI6ImFkdzlyeTM..."
     #
-    #     plugin :download_endpoint, host: "http://abc123.cloudfront.net"
+    # ## Performance considerations
     #
-    # or configure the endpoint to redirect to the direct file URL:
+    # Streaming files through the app might impact the request throughput,
+    # depending on the web server you're using. So it's recommended to use a
+    # CDN, which can be set via the `:host` option.
+    #
+    # Alternatively, you can have the endpoint redirect to the direct file URL:
     #
     #     plugin :download_endpoint, redirect: true
     #     # or
@@ -57,13 +65,16 @@ class Shrine
     #       # return URL which the request will redirect to
     #     end
     #
-    # Alternatively, you can stream files yourself from your controller using
-    # the `rack_response` plugin, which this plugin uses internally.
+    # ## Custom endpoint
+    #
+    # If you want to have more control on download requests, you can use the
+    # `rack_response` plugin which this plugin uses internally.
     #
     # [Roda]: https://github.com/jeremyevans/roda
     module DownloadEndpoint
       def self.load_dependencies(uploader, opts = {})
         uploader.plugin :rack_response
+        uploader.plugin :_urlsafe_serialization
       end
 
       # Accepts the following options:
@@ -121,11 +132,7 @@ class Shrine
           @download_endpoint = endpoint_class
 
           const_set(:DownloadEndpoint, endpoint_class)
-          deprecate_constant(:DownloadEndpoint) if RUBY_VERSION > "2.3"
-        end
-
-        def download_endpoint_serializer
-          @download_endpoint_serializer ||= Serializer.new
+          deprecate_constant(:DownloadEndpoint)
         end
       end
 
@@ -142,34 +149,45 @@ class Shrine
           end
         end
 
-        def download_url
-          [download_host, *download_prefix, download_identifier].join("/")
+        # Returns file URL on the download endpoint.
+        def download_url(**options)
+          FileUrl.new(self).call(**options)
         end
 
         private
 
-        # Generates URL-safe identifier from data, filtering only a subset of
-        # metadata that the endpoint needs to prevent the URL from being too
-        # long.
-        def download_identifier
-          semantical_metadata = metadata.select { |name, _| %w[filename size mime_type].include?(name) }
-          download_serializer.dump(data.merge("metadata" => semantical_metadata.sort.to_h))
+        def download_storages
+          shrine_class.opts[:download_endpoint_storages]
+        end
+      end
+
+      class FileUrl
+        attr_reader :file
+
+        def initialize(file)
+          @file = file
         end
 
-        def download_serializer
-          shrine_class.download_endpoint_serializer
+        def call(host: self.host)
+          [host, *prefix, path].join("/")
         end
 
-        def download_host
+        protected
+
+        def path
+          file.urlsafe_dump(metadata: %w[filename size mime_type])
+        end
+
+        def host
           shrine_class.opts[:download_endpoint_host]
         end
 
-        def download_prefix
+        def prefix
           shrine_class.opts[:download_endpoint_prefix]
         end
 
-        def download_storages
-          shrine_class.opts[:download_endpoint_storages]
+        def shrine_class
+          file.shrine_class
         end
       end
 
@@ -181,23 +199,25 @@ class Shrine
           # handle legacy ":storage/:id" URLs
           r.on storage_names do |storage_name|
             r.get /(.*)/ do |id|
-              data = { "id" => id, "storage" => storage_name, "metadata" => {} }
-              serve_file(data)
+              uploaded_file = shrine_class::UploadedFile.new(
+                "id"       => id,
+                "storage"  => storage_name,
+              )
+
+              serve_file(uploaded_file)
             end
           end
 
-          r.get /(.*)/ do |identifier|
-            data = serializer.load(identifier)
-            serve_file(data)
+          r.get /(.*)/ do |serialized|
+            uploaded_file = get_uploaded_file(serialized)
+            serve_file(uploaded_file)
           end
         end
 
         private
 
         # Streams or redirects to the uploaded file.
-        def serve_file(data)
-          uploaded_file = get_uploaded_file(data)
-
+        def serve_file(uploaded_file)
           if redirect
             redirect_to_file(uploaded_file)
           else
@@ -227,11 +247,11 @@ class Shrine
         end
 
         # Returns a Shrine::UploadedFile, or returns 404 if file doesn't exist.
-        def get_uploaded_file(data)
-          uploaded_file = shrine_class.uploaded_file(data)
+        def get_uploaded_file(serialized)
+          uploaded_file = shrine_class::UploadedFile.urlsafe_load(serialized)
           not_found! unless uploaded_file.exists?
           uploaded_file
-        rescue Shrine::Error
+        rescue Shrine::Error # storage not found
           not_found!
         end
 
@@ -251,10 +271,6 @@ class Shrine
           shrine_class.storages.keys.map(&:to_s)
         end
 
-        def serializer
-          shrine_class.download_endpoint_serializer
-        end
-
         def redirect
           opts[:redirect]
         end
@@ -267,34 +283,6 @@ class Shrine
           opts[:shrine_class]
         end
       end
-
-      class Serializer
-        def dump(data)
-          base64_encode(json_encode(data))
-        end
-
-        def load(data)
-          json_decode(base64_decode(data))
-        end
-
-        private
-
-        def json_encode(data)
-          JSON.generate(data)
-        end
-
-        def base64_encode(data)
-          Base64.urlsafe_encode64(data)
-        end
-
-        def base64_decode(data)
-          Base64.urlsafe_decode64(data)
-        end
-
-        def json_decode(data)
-          JSON.parse(data)
-        end
-      end
     end
 
     register_plugin(:download_endpoint, DownloadEndpoint)