carrierwave 3.1.4 → 4.0.0.rc

data/lib/carrierwave/orm/activerecord.rb

@@ -6,6 +6,38 @@ module CarrierWave
 
     include CarrierWave::Mount
 
+    ##
+    # See +CarrierWave::Mount#mount_uploader+ for documentation
+    #
+    def mount_uploader(column, uploader=nil, options={}, &block)
+      super
+
+      mod = Module.new
+      prepend mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def remote_#{column}_url=(url)
+          super
+          mark_#{column}_changed_on_error
+        end
+      RUBY
+    end
+
+    ##
+    # See +CarrierWave::Mount#mount_uploaders+ for documentation
+    #
+    def mount_uploaders(column, uploader=nil, options={}, &block)
+      super
+
+      mod = Module.new
+      prepend mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def remote_#{column}_urls=(urls)
+          super
+          mark_#{column}_changed_on_error
+        end
+      RUBY
+    end
+
   private
 
     def mount_base(column, uploader=nil, options={}, &block)
@@ -52,6 +84,9 @@ module CarrierWave
           @_mounters[:"#{column}"] = nil
           # The attribute needs to be cleared to prevent it from picked up as identifier
           write_uploader(_mounter(:#{column}).serialization_column, nil)
+          if (metadata_column = _mounter(:#{column}).metadata_column)
+            write_uploader(metadata_column, nil)
+          end
           _mounter(:"#{column}").cache(old_uploaders)
         end
 
@@ -59,6 +94,22 @@ module CarrierWave
           return unless has_attribute?(_mounter(:#{column}).serialization_column)
           super
         end
+
+        def #{column}=(new_file)
+          super
+          mark_#{column}_changed_on_error
+        end
+
+      private
+
+        # A refusal leaves the column as it was, and a record saved through an
+        # association is only validated when it changed, so say it changed
+        def mark_#{column}_changed_on_error
+          return if #{column}_integrity_errors.empty? && #{column}_processing_errors.empty? &&
+            #{column}_download_errors.empty?
+
+          __send__(:"\#{_mounter(:#{column}).serialization_column}_will_change!")
+        end
       RUBY
     end
 

data/lib/carrierwave/processing/mini_magick.rb

@@ -96,7 +96,7 @@ module CarrierWave
     #
     # === Yields
     #
-    # [MiniMagick::Image] additional manipulations to perform
+    # [MiniMagick::Image] additional manipulations to perform (deprecated, use #manipulate!)
     #
     # === Examples
     #
@@ -124,7 +124,7 @@ module CarrierWave
     #
     # === Yields
     #
-    # [MiniMagick::Image] additional manipulations to perform
+    # [MiniMagick::Image] additional manipulations to perform (deprecated, use #manipulate!)
     #
     def resize_to_limit(width, height, combine_options: {}, &block)
       width, height = resolve_dimensions(width, height)
@@ -148,7 +148,7 @@ module CarrierWave
     #
     # === Yields
     #
-    # [MiniMagick::Image] additional manipulations to perform
+    # [MiniMagick::Image] additional manipulations to perform (deprecated, use #manipulate!)
     #
     def resize_to_fit(width, height, combine_options: {}, &block)
       width, height = resolve_dimensions(width, height)
@@ -173,7 +173,7 @@ module CarrierWave
     #
     # === Yields
     #
-    # [MiniMagick::Image] additional manipulations to perform
+    # [MiniMagick::Image] additional manipulations to perform (deprecated, use #manipulate!)
     #
     def resize_to_fill(width, height, gravity = 'Center', combine_options: {}, &block)
       width, height = resolve_dimensions(width, height)
@@ -203,7 +203,7 @@ module CarrierWave
     #
     # === Yields
     #
-    # [MiniMagick::Image] additional manipulations to perform
+    # [MiniMagick::Image] additional manipulations to perform (deprecated, use #manipulate!)
     #
     def resize_and_pad(width, height, background=:transparent, gravity='Center', combine_options: {}, &block)
       width, height = resolve_dimensions(width, height)
@@ -228,7 +228,7 @@ module CarrierWave
     #
     # === Yields
     #
-    # [MiniMagick::Image] additional manipulations to perform
+    # [MiniMagick::Image] additional manipulations to perform (deprecated, use #manipulate!)
     #
     def crop(left, top, width, height, combine_options: {}, &block)
       width, height = resolve_dimensions(width, height)
@@ -290,6 +290,7 @@ module CarrierWave
 
       image = yield(image)
       FileUtils.mv image.path, current_path
+      follow_extension_of image.path
 
       ::MiniMagick::Image.new(current_path).identify
     rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
@@ -325,20 +326,20 @@ module CarrierWave
       result = builder.call
       result.close
 
-      # backwards compatibility (we want to eventually move away from MiniMagick::Image)
       if block
+        unless @minimagick_image_block_warned
+          @minimagick_image_block_warned = true
+          CarrierWave.deprecator.warn "Passing a block to receive a MiniMagick::Image is deprecated. " \
+                                      "Use #manipulate! to work with a MiniMagick::Image, or #minimagick! to build on the ImageProcessing builder."
+        end
+
         image  = ::MiniMagick::Image.new(result.path, result)
         image  = block.call(image)
         result = image.instance_variable_get(:@tempfile)
       end
 
       FileUtils.mv result.path, current_path
-
-      if File.extname(result.path) != File.extname(current_path)
-        move_to = current_path.chomp(File.extname(current_path)) + File.extname(result.path)
-        file.content_type = Marcel::Magic.by_path(move_to).try(:type)
-        file.move_to(move_to, permissions, directory_permissions)
-      end
+      follow_extension_of result.path
     rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
       raise e if e.message =~ /(You must have .+ installed|is not installed|executable not found)/
       message = I18n.translate(:"errors.messages.processing_error")
@@ -347,6 +348,16 @@ module CarrierWave
 
   private
 
+    # The processing may have changed the format, in which case the file is renamed so
+    # that its extension keeps telling what it actually holds
+    def follow_extension_of(processed_path)
+      return if File.extname(processed_path) == File.extname(current_path)
+
+      move_to = current_path.chomp(File.extname(current_path)) + File.extname(processed_path)
+      file.content_type = Marcel::Magic.by_path(move_to).try(:type)
+      file.move_to(move_to, permissions, directory_permissions)
+    end
+
     def resolve_dimensions(*dimensions)
       dimensions.map do |value|
         next value unless value.instance_of?(Proc)

data/lib/carrierwave/processing/rmagick.rb

@@ -383,6 +383,11 @@ module CarrierWave
         frame = yield(*[frame, index, options].take(block.arity)) if block_given?
         frames << frame if frame
       end
+
+      if frames.none?
+        raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.unsupported_image_format_error")
+      end
+
       frames.append(true) if block_given?
 
       write_block = create_info_block(options[:write])

data/lib/carrierwave/processing/vips.rb

@@ -93,10 +93,6 @@ module CarrierWave
     #
     # [format (#to_s)] an abbreviation of the format
     #
-    # === Yields
-    #
-    # [Vips::Image] additional manipulations to perform
-    #
     # === Examples
     #
     #     image.convert(:png)
@@ -121,10 +117,6 @@ module CarrierWave
     # [height (Integer)] the height to scale the image to
     # [combine_options (Hash)] additional Vips options to apply before resizing
     #
-    # === Yields
-    #
-    # [Vips::Image] additional manipulations to perform
-    #
     def resize_to_limit(width, height, combine_options: {})
       width, height = resolve_dimensions(width, height)
 
@@ -145,10 +137,6 @@ module CarrierWave
     # [height (Integer)] the height to scale the image to
     # [combine_options (Hash)] additional Vips options to apply before resizing
     #
-    # === Yields
-    #
-    # [Vips::Image] additional manipulations to perform
-    #
     def resize_to_fit(width, height, combine_options: {})
       width, height = resolve_dimensions(width, height)
 
@@ -169,10 +157,6 @@ module CarrierWave
     # [height (Integer)] the height to scale the image to
     # [combine_options (Hash)] additional vips options to apply before resizing
     #
-    # === Yields
-    #
-    # [Vips::Image] additional manipulations to perform
-    #
     def resize_to_fill(width, height, _gravity = nil, combine_options: {})
       width, height = resolve_dimensions(width, height)
 
@@ -199,10 +183,6 @@ module CarrierWave
     # [alpha (Boolean, nil)] pad the image with the alpha channel if supported
     # [combine_options (Hash)] additional vips options to apply before resizing
     #
-    # === Yields
-    #
-    # [Vips::Image] additional manipulations to perform
-    #
     def resize_and_pad(width, height, background=nil, gravity='centre', alpha=nil, combine_options: {})
       width, height = resolve_dimensions(width, height)
 
@@ -224,10 +204,6 @@ module CarrierWave
     # [width (Integer)] width of area to extract
     # [height (Integer)] height of area to extract
     #
-    # === Yields
-    #
-    # [Vips::Image] additional manipulations to perform
-    #
     def crop(left, top, width, height, combine_options: {})
       width, height = resolve_dimensions(width, height)
       width = vips_image.width - left if width + left > vips_image.width

data/lib/carrierwave/sanitized_file.rb

@@ -53,7 +53,7 @@ module CarrierWave
     # [String] the sanitized filename
     #
     def filename
-      sanitize(original_filename) if original_filename
+      sanitize(original_filename.to_s)
     end
 
     alias_method :identifier, :filename
@@ -305,7 +305,7 @@ module CarrierWave
 
     # Sanitize the filename, to prevent hacking
     def sanitize(name)
-      name = name.scrub
+      name = name.scrub.delete("\0") # a NUL byte cuts the path short, and File.basename refuses one
       name = name.tr("\\", "/") # work-around for IE
       name = File.basename(name)
       name = name.gsub(sanitize_regexp, "_")

data/lib/carrierwave/storage/abstract.rb

@@ -31,6 +31,15 @@ module CarrierWave
         raise NotImplementedError, "Need to implement #retrieve_from_cache! if you want to use #{self.class.name} as a cache storage."
       end
 
+      # Storage engines which defer writing to the cache have to flush it here
+      def materialize_cache!(file)
+        file
+      end
+
+      def direct_upload_url(path, expires_in:, headers: {})
+        raise NotImplementedError, "Need to implement #direct_upload_url if you want to use #{self.class.name} for direct uploads."
+      end
+
       def delete_dir!(path)
         raise NotImplementedError, "Need to implement #delete_dir! if you want to use #{self.class.name} as a cache storage."
       end

data/lib/carrierwave/storage/file.rb

@@ -110,10 +110,8 @@ module CarrierWave
 
       def clean_cache!(seconds)
         Dir.glob(::File.expand_path(::File.join(uploader.cache_dir, '*'), uploader.root)).each do |dir|
-          # generate_cache_id returns key formatted TIMEINT-PID(-COUNTER)-RND
-          matched = dir.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first
-          next unless matched
-          time = Time.at(matched[0].to_i)
+          time = uploader.parse_cache_id(::File.basename(dir))
+          next unless time
           if time < (Time.now.utc - seconds)
             FileUtils.rm_rf(dir)
           end

data/lib/carrierwave/storage/fog.rb

@@ -12,6 +12,13 @@ module CarrierWave
     # [:fog_directory]    specifies name of directory to store data in, assumed to already exist
     #
     # [:fog_attributes]                   (optional) additional attributes to set on files
+    # [:fog_acl]                          (optional) overrides the ACL set on stored/copied files.
+    #   When nil (default), ACL is derived from fog_public (:public attribute passed to fog).
+    #   When false, no ACL is set at all (omits :public; use for buckets/containers with ACLs disabled).
+    #   When a String, used as the explicit ACL value: passed as x-amz-acl for AWS
+    #   (e.g. 'bucket-owner-full-control') or destination_predefined_acl for Google
+    #   (e.g. 'bucketOwnerFullControl'). For store operations, pair with fog_attributes to
+    #   set the provider-specific header.
     # [:fog_public]                       (optional) public readability, defaults to true
     # [:fog_authenticated_url_expiration] (optional) time (in seconds) that authenticated urls
     #   will be valid, when fog_public is false and provider is AWS or Google, defaults to 600
@@ -105,7 +112,8 @@ module CarrierWave
       end
 
       ##
-      # Stores given file to cache directory.
+      # Stages given file to be cached, deferring the upload until #materialize_cache!,
+      # as a cached file usually goes straight to the store within the same request.
       #
       # === Parameters
       #
@@ -113,12 +121,35 @@ module CarrierWave
       #
       # === Returns
       #
-      # [CarrierWave::SanitizedFile] a sanitized file
+      # [CarrierWave::SanitizedFile] the staged file
+      #   or
+      # [CarrierWave::Storage::Fog::File] the uploaded file, with cache_only
       #
       def cache!(new_file)
-        f = CarrierWave::Storage::Fog::File.new(uploader, self, uploader.cache_path)
-        f.store(new_file)
-        f
+        # With cache_only there's no store to move to, so the cache is the final location
+        return upload_to_cache(new_file) if uploader.cache_only
+
+        local_storage.cache!(new_file)
+      end
+
+      ##
+      # Uploads the staged file to the cache directory.
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the staged file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::Fog::File] the uploaded file
+      #
+      def materialize_cache!(file)
+        return file if file.is_a?(CarrierWave::Storage::Fog::File)
+
+        upload_to_cache(file).tap do
+          file.delete
+          local_storage.delete_dir!(uploader.cache_path(nil))
+        end
       end
 
       ##
@@ -140,22 +171,36 @@ module CarrierWave
       # Deletes a cache dir
       #
       def delete_dir!(path)
-        # do nothing, because there's no such things as 'empty directory'
+        # Only the local cache has dirs, as there's no such things as 'empty directory'
+        local_storage.delete_dir!(path)
+      end
+
+      ##
+      # Returns a URL a client can PUT the file to, to cache it without the bytes
+      # passing through the application.
+      #
+      def direct_upload_url(path, expires_in:, headers: {})
+        connection.put_object_url(uploader.fog_directory, path, ::Fog::Time.now.since(expires_in), headers)
       end
 
       def clean_cache!(seconds)
-        connection.directories.new(
-          :key    => uploader.fog_directory,
-          :public => uploader.fog_public
-        ).files.all(:prefix => uploader.cache_dir).each do |file|
-          # generate_cache_id returns key formatted TIMEINT-PID(-COUNTER)-RND
-          matched = file.key.match(/(\d+)-\d+-\d+(?:-\d+)?/)
-          next unless matched
-          time = Time.at(matched[1].to_i)
+        local_storage.clean_cache!(seconds)
+        directory = connection.directories.new(fog_public_attrs.merge(:key => uploader.fog_directory))
+        prefix = "#{uploader.cache_dir.to_s.chomp('/')}/"
+        directory.files.all(:prefix => prefix).each do |file|
+          # the prefix is checked again, as some providers may not honor it when listing
+          next unless file.key.start_with?(prefix)
+
+          time = uploader.parse_cache_id(file.key.delete_prefix(prefix).split('/').first)
+          next unless time
           file.destroy if time < (Time.now.utc - seconds)
         end
       end
 
+      def fog_public_attrs
+        uploader.fog_acl.nil? ? { :public => uploader.fog_public } : {}
+      end
+
       def connection
         @connection ||= begin
           options = credentials = uploader.fog_credentials
@@ -296,7 +341,7 @@ module CarrierWave
           return read_source_file if ::File.exist?(file_body.path)
 
           # If the source file doesn't exist, the remote content is read
-          @file = nil
+          remove_instance_variable(:@file)
           file.body
         end
 
@@ -308,7 +353,7 @@ module CarrierWave
         # [Integer] size of file body
         #
         def size
-          file.nil? ? 0 : file.content_length
+          file&.content_length || 0
         end
 
         ##
@@ -342,12 +387,11 @@ module CarrierWave
           else
             fog_file = new_file.to_file
             @content_type ||= new_file.content_type
-            @file = directory.files.create({
+            @file = directory.files.create(fog_public_attrs.merge(
               :body         => fog_file || new_file.read,
               :content_type => @content_type,
-              :key          => path,
-              :public       => @uploader.fog_public
-            }.merge(@uploader.fog_attributes))
+              :key          => path
+            ).merge(@uploader.fog_attributes))
             fog_file.close if fog_file && !fog_file.closed?
           end
           true
@@ -439,11 +483,12 @@ module CarrierWave
         #
         def filename(options = {})
           return unless (file_url = url(options))
-          CGI.unescape(file_url.split('?').first).gsub(/.*\/(.*?$)/, '\1')
+          decode_path(file_url.split('?').first).gsub(/.*\/(.*?$)/, '\1')
         end
 
         ##
-        # Creates a copy of this file and returns it.
+        # Creates a copy of this file and returns it. Copying to where the file already is
+        # leaves it alone, as S3 refuses a copy onto the same key.
         #
         # === Parameters
         #
@@ -454,7 +499,7 @@ module CarrierWave
         # @return [CarrierWave::Storage::Fog::File] the location where the file will be stored.
         #
         def copy_to(new_path)
-          file.copy(@uploader.fog_directory, new_path, copy_options)
+          file.copy(@uploader.fog_directory, new_path, copy_options) unless new_path == path
           CarrierWave::Storage::Fog::File.new(@uploader, @base, new_path)
         end
 
@@ -498,10 +543,7 @@ module CarrierWave
         # [Fog::#{provider}::Directory] containing directory
         #
         def directory
-          @directory ||= connection.directories.new(
-            :key    => @uploader.fog_directory,
-            :public => @uploader.fog_public
-          )
+          @directory ||= connection.directories.new(fog_public_attrs.merge(:key => @uploader.fog_directory))
         end
 
         ##
@@ -512,7 +554,9 @@ module CarrierWave
         # [Fog::#{provider}::File] file data from remote service
         #
         def file
-          @file ||= directory.files.head(path)
+          return @file if defined?(@file)
+
+          @file = directory.files.head(path)
         end
 
         def copy_options
@@ -523,11 +567,19 @@ module CarrierWave
         end
 
         def acl_header
+          fog_acl = @uploader.fog_acl
+          return {} if fog_acl == false
+
           case fog_provider
           when 'AWS'
-            { 'x-amz-acl' => @uploader.fog_public ? 'public-read' : 'private' }
+            acl_value = fog_acl || (@uploader.fog_public ? 'public-read' : 'private')
+            { 'x-amz-acl' => acl_value }
           when "Google"
-            @uploader.fog_public ? { destination_predefined_acl: "publicRead" } : {}
+            if fog_acl
+              { destination_predefined_acl: fog_acl }
+            else
+              @uploader.fog_public ? { destination_predefined_acl: "publicRead" } : {}
+            end
           else
             {}
           end
@@ -537,6 +589,10 @@ module CarrierWave
           @uploader.fog_credentials[:provider].to_s
         end
 
+        def fog_public_attrs
+          @uploader.fog_acl.nil? ? { :public => @uploader.fog_public } : {}
+        end
+
         def read_source_file
           source_file = to_file
           return unless source_file
@@ -554,6 +610,18 @@ module CarrierWave
         end
       end
 
+    private
+
+      def upload_to_cache(new_file)
+        f = CarrierWave::Storage::Fog::File.new(uploader, self, uploader.cache_path)
+        f.store(new_file)
+        f
+      end
+
+      def local_storage
+        @local_storage ||= CarrierWave::Storage::File.new(uploader)
+      end
+
     end # Fog
 
   end # Storage

data/lib/carrierwave/test/matchers.rb

@@ -336,6 +336,8 @@ module CarrierWave
         def self.load_image(filename)
           if defined? ::MiniMagick
             MiniMagickWrapper.new(filename)
+          elsif defined? ::Vips
+            VipsWrapper.new(filename)
           else
             unless defined? ::Magick
               begin
@@ -393,6 +395,28 @@ module CarrierWave
         end
       end
 
+      class VipsWrapper # :nodoc:
+        attr_reader :image
+
+        def width
+          image.width
+        end
+
+        def height
+          image.height
+        end
+
+        def format
+          # This returns the name of the vips loader (e.g. pngload) as Vips
+          # doesn't do content detection.
+          image.get("vips-loader").delete_suffix("load")
+        end
+
+        def initialize(filename)
+          @image = ::Vips::Image.new_from_file(filename)
+        end
+      end
+
     end # Matchers
   end # Test
 end # CarrierWave

data/lib/carrierwave/uploader/cache.rb

@@ -81,10 +81,9 @@ module CarrierWave
       end
 
       ##
-      # Caches the remotely stored file
-      #
-      # This is useful when about to process images. Most processing solutions
-      # require the file to be stored on the local filesystem.
+      # Caches the stored file, so that it can be processed. Most processing solutions
+      # require the file to be on the local filesystem. It is staged as any assigned
+      # file is, so the next save stores the result; use #read for a copy only to read.
       #
       def cache_stored_file!
         cache!
@@ -103,7 +102,29 @@ module CarrierWave
       # [String] a cache name, in the format TIMEINT-PID-COUNTER-RND/filename.txt
       #
       def cache_name
-        File.join(cache_id, original_filename) if cache_id && original_filename
+        File.join(*[cache_id, original_filename].compact) if cache_id
+      end
+
+      ##
+      # Tells when the given cache id was created, and by returning nil, that it is
+      # not one. Override to take cache ids which were made elsewhere.
+      #
+      # === Parameters
+      #
+      # [cache_id (String)] the cache id to look at
+      #
+      # === Returns
+      #
+      # [Time] when it was created
+      #   or
+      # [NilClass] if it isn't a cache id
+      #
+      def parse_cache_id(cache_id)
+        # Earlier version used 3 part cache_id. Thus we should allow for
+        # the cache_id to have both 3 part and 4 part formats.
+        return unless cache_id.to_s =~ /\A(-?\d+)-\d+(-\d{4})?-\d{4}\z/
+
+        Time.at($1.to_i)
       end
 
       ##
@@ -146,11 +167,24 @@ module CarrierWave
           with_callbacks(:cache, @file) do
             @file = cache_storage.cache!(@file)
           end
+        rescue Errno::ENAMETOOLONG
+          # How long a name may be is the filesystem's to say, so let it say it
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.filename_too_long_error")
         ensure
           FileUtils.rm_rf(workfile_path(''))
         end
       end
 
+      ##
+      # Makes sure the cached file is written to the cache storage, which may have
+      # deferred it. Needed when the file has to outlive the current request.
+      #
+      def materialize_cache!
+        with_callbacks(:materialize_cache) do
+          @file = cache_storage.materialize_cache!(@file) if @file
+        end
+      end
+
       ##
       # Retrieves the file with the given cache_name from the cache.
       #
@@ -199,9 +233,7 @@ module CarrierWave
       attr_reader :original_filename
 
       def cache_id=(cache_id)
-        # Earlier version used 3 part cache_id. Thus we should allow for
-        # the cache_id to have both 3 part and 4 part formats.
-        raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A(-)?[\d]+\-[\d]+(\-[\d]{4})?\-[\d]{4}\z/
+        raise CarrierWave::InvalidParameter, "invalid cache id" unless parse_cache_id(cache_id)
         @cache_id = cache_id
       end
 
@@ -211,7 +243,8 @@ module CarrierWave
       end
 
       def cache_storage
-        @cache_storage ||= (self.class.cache_storage || self.class.storage).new(self)
+        # Falls back to this uploader's storage, which may not be the configured one
+        @cache_storage ||= self.class.cache_storage&.new(self) || storage
       end
 
       # We can override the full_original_filename method in other modules