carrierwave 2.2.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b815c0a48b4df1ed7a3c3ea6f0d3cf4748b9197d5507b7b99ba262bcf703f8de
-  data.tar.gz: b162ccab7c487c367702310819a3e14a05f014abed916a79112520550877a477
+  metadata.gz: 418e6b0903adc403510724ba7a5764e8edaa5b4bc96d5313e8f01572bf26ceac
+  data.tar.gz: 0bbac560a7928ce059afccb2280a1f77d17c9bca418a3f471097a3e3375fc6d0
 SHA512:
-  metadata.gz: a6341493e822abeaa770f1c202e3ca62c43b54a2dcf1768e7d485208f825a546354d66b9c45d1169c2636d32a39b36312a8029729009504b87ab2ff6b8500187
-  data.tar.gz: 9a8f6b9f5c2ba84f500a051f1ad9f7da603af42a746422f5a727fe79c02eb1cd9063c5b082fd7a051f263b52918d76a1abeb16ee4bb2dd8ecaea73d4a9f732fe
+  metadata.gz: 253d7d3f2e78fd169e347042c6eae2d5ab70f1383dc159988387215cb669ca905232817484f168816c21bcfb6733221a69c6ae02d7a463df920446ee53ae8efd
+  data.tar.gz: 7640c8c67f2bb11025a42c9b05752a167a3da4d3452dc3359ffc51e5cb5ea8460fd23be401446734daa573e77f9a0639b7f2cf053288d8c5360e63907a80f08c

data/README.md

@@ -10,7 +10,7 @@ It works well with Rack based web applications, such as Ruby on Rails.
 
 ## Information
 
-* RDoc documentation [available on RubyDoc.info](http://rubydoc.info/gems/carrierwave/frames)
+* RDoc documentation [available on RubyDoc.info](https://rubydoc.info/gems/carrierwave)
 * Source code [available on GitHub](http://github.com/carrierwaveuploader/carrierwave)
 * More information, known limitations, and how-tos [available on the wiki](https://github.com/carrierwaveuploader/carrierwave/wiki)
 
@@ -30,13 +30,19 @@ $ gem install carrierwave
 In Rails, add it to your Gemfile:
 
 ```ruby
-gem 'carrierwave', '~> 2.0'
+gem 'carrierwave', '~> 3.0'
 ```
 
 Finally, restart the server to apply the changes.
 
-As of version 2.0, CarrierWave requires Rails 5.0 or higher and Ruby 2.2
-or higher. If you're on Rails 4, you should use 1.x.
+## Upgrading from 2.x or earlier
+
+CarrierWave 3.0 comes with a change in the way of handling the file extension on conversion. This results in following issues if you use `process convert: :format` to change the file format:
+
+- If you have it on the uploader itself (not within a version), the file extension of the cached file will change. That means if you serve both CarrierWave 2.x and 3.x simultaneously on the same workload (e.g. using blue-green deployment), a cache file stored by 2.x can't be retrieved by 3.x and vice versa.
+- If you have it within a version, the file extension of the stored file will change. You need to perform `#recreate_versions!` to make it usable again.
+
+To preserve the 2.x behavior, you can set `force_extension false` right after calling `process convert: :format`. See [#2659](https://github.com/carrierwaveuploader/carrierwave/pull/2659) for the detail.
 
 ## Getting Started
 
@@ -227,6 +233,20 @@ class MyUploader < CarrierWave::Uploader::Base
 end
 ```
 
+## Changing the filename
+
+To change the filename of uploaded files, you can override `#filename` method in the uploader.
+
+```ruby
+class MyUploader < CarrierWave::Uploader::Base
+  def filename
+    "image.#{file.extension}" # If you upload 'file.jpg', you'll get 'image.jpg'
+  end
+end
+```
+
+Some old documentations (like [this](https://stackoverflow.com/a/5865117)) may instruct you to safeguard the filename value with `if original_filename`, but it's no longer necessary with CarrierWave 3.0 or later.
+
 ## Securing uploads
 
 Certain files might be dangerous if uploaded to the wrong location, such as PHP
@@ -305,17 +325,8 @@ You no longer need to do this manually.
 
 ## Adding versions
 
-Often you'll want to add different versions of the same file. The classic example is image thumbnails. There is built in support for this*:
-
-*Note:* You must have Imagemagick installed to do image resizing.
-
-Some documentation refers to RMagick instead of MiniMagick but MiniMagick is recommended.
-
-To install Imagemagick on OSX with homebrew type the following:
-
-```
-$ brew install imagemagick
-```
+Often you'll want to add different versions of the same file. The classic example is generating image thumbnails while preserving the original file to be used for high-quality representation.
+In this section we'll explore how CarrierWave supports working with multiple versions. The image manipulation itself is covered in [another section](#manipulating-images).
 
 ```ruby
 class MyUploader < CarrierWave::Uploader::Base
@@ -351,17 +362,7 @@ uploader.thumb.url # => '/url/to/thumb_my_file.png'   # size: 200x200
 One important thing to remember is that process is called *before* versions are
 created. This can cut down on processing cost.
 
-### Processing Methods: mini_magick
-
-- `convert` - Changes the image encoding format to the given format, eg. jpg
-- `resize_to_limit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. Will only resize the image if it is larger than the specified dimensions. The resulting image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
-- `resize_to_fit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. The image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
-- `resize_to_fill` - Resize the image to fit within the specified dimensions while retaining the aspect ratio of the original image. If necessary, crop the image in the larger dimension. Optionally, a "gravity" may be specified, for example "Center", or "NorthEast".
-- `resize_and_pad` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. If necessary, will pad the remaining area with the given color, which defaults to transparent (for gif and png, white for jpeg). Optionally, a "gravity" may be specified, as above.
-
-See `carrierwave/processing/mini_magick.rb` for details.
-
-### conditional process
+### Conditional processing
 
 If you want to use conditional process, you can only use `if` statement.
 
@@ -445,8 +446,27 @@ class MyUploader < CarrierWave::Uploader::Base
 end
 ```
 
-The option `:from_version` uses the file cached in the `:thumb` version instead
-of the original version, potentially resulting in faster processing.
+### Customizing version filenames
+
+CarrierWave supports [customization of filename](#changing-the-filename) by overriding an uploader's
+#filename method, but this doesn't work for versions because of the limitation on how CarrierWave
+re-constructs the filename on retrieval of the stored file.
+Instead, you can override `#full_filename` with providing a version-aware name.
+
+```ruby
+class MyUploader < CarrierWave::Uploader::Base
+  version :thumb do
+    def full_filename(for_file)
+      'thumb.png'
+    end
+    process convert: 'png'
+  end
+end
+```
+
+Please note that `#full_filename` mustn't be constructed based on a dynamic value
+that can change from the time of store and time of retrieval, since it will result in
+being unable to retrieve a file previously stored.
 
 ## Making uploads work across form redisplays
 
@@ -531,6 +551,17 @@ failures automatically with attribute validation errors. If you aren't, or you
 disable CarrierWave's `validate_download` option, you'll need to handle those
 errors yourself.
 
+### Retry option for download from remote location
+If you want to retry the download from the Remote URL, enable the download_retry_count option, an error occurs during download, it will try to execute the specified number of times.
+This option is effective when the remote destination is unstable.
+
+```rb
+CarrierWave.configure do |config|
+  config.download_retry_count = 3 # Default 0
+  config.download_retry_wait_time = 3 # Default 5
+end
+```
+
 ## Providing a default URL
 
 In many cases, especially when working with images, it might be a good idea to
@@ -628,14 +659,17 @@ end
 ## Testing with CarrierWave
 
 It's a good idea to test your uploaders in isolation. In order to speed up your
-tests, it's recommended to switch off processing in your tests, and to use the
-file storage. In Rails you could do that by adding an initializer with:
+tests, it's recommended to switch off processing in your tests, and to use the file storage.
+Also, you can disable SSRF protection at your own risk using the `skip_ssrf_protection` configuration.
+
+In Rails you could do that by adding an initializer with:
 
 ```ruby
 if Rails.env.test? or Rails.env.cucumber?
   CarrierWave.configure do |config|
     config.storage = :file
     config.enable_processing = false
+    config.skip_ssrf_protection = true
   end
 end
 ```
@@ -733,6 +767,10 @@ CarrierWave.configure do |config|
   config.fog_directory  = 'name_of_bucket'                                      # required
   config.fog_public     = false                                                 # optional, defaults to true
   config.fog_attributes = { cache_control: "public, max-age=#{365.days.to_i}" } # optional, defaults to {}
+  # Use this if you have AWS S3 ACLs disabled.
+  # config.fog_attributes = { 'x-amz-acl' => 'bucket-owner-full-control' }
+  # Use this if you have Google Cloud Storage uniform bucket-level access enabled.
+  # config.fog_attributes = { uniform: true }
   # For an application which utilizes multiple servers but does not need caches persisted across requests,
   # uncomment the line :file instead of the default :storage.  Otherwise, it will use AWS as the temp cache store.
   # config.cache_storage = :file
@@ -766,7 +804,7 @@ gem "fog"
 ```
 
 You'll need to configure a directory (also known as a container), username and API key in the initializer.
-For the sake of performance it is assumed that the directory already exists, so please create it if need be.
+For the sake of performance it is assumed that the directory already exists, so please create it if needs to be.
 
 Using a US-based account:
 
@@ -825,14 +863,13 @@ gem "fog-google"
 ```
 
 You'll need to configure a directory (also known as a bucket) and the credentials in the initializer.
-For the sake of performance it is assumed that the directory already exists, so please create it if need be.
+For the sake of performance it is assumed that the directory already exists, so please create it if needs to be.
 
 Please read the [fog-google README](https://github.com/fog/fog-google/blob/master/README.md) on how to get credentials.
 
 For Google Storage JSON API (recommended):
 ```ruby
 CarrierWave.configure do |config|
-    config.fog_provider = 'fog/google'
     config.fog_credentials = {
         provider:               'Google',
         google_project:         'my-project',
@@ -846,7 +883,6 @@ end
 For Google Storage XML API:
 ```ruby
 CarrierWave.configure do |config|
-    config.fog_provider = 'fog/google'
     config.fog_credentials = {
         provider:                         'Google',
         google_storage_access_key_id:     'xxxxxx',
@@ -905,12 +941,48 @@ CarrierWave.configure do |config|
 end
 ```
 
-## Using RMagick
+## Manipulating images
 
 If you're uploading images, you'll probably want to manipulate them in some way,
-you might want to create thumbnail images for example. CarrierWave comes with a
-small library to make manipulating images with RMagick easier, you'll need to
-include it in your Uploader:
+you might want to create thumbnail images for example.
+
+### Using MiniMagick
+
+MiniMagick performs all the operations using the 'convert' CLI which is part of the standard ImageMagick kit.
+This allows you to have the power of ImageMagick without having to worry about installing
+all the RMagick libraries, it often results in higher memory footprint.
+
+See the MiniMagick site for more details:
+
+https://github.com/minimagick/minimagick
+
+To install Imagemagick on OSX with homebrew type the following:
+
+```
+$ brew install imagemagick
+```
+
+And the ImageMagick command line options for more for what's on offer:
+
+http://www.imagemagick.org/script/command-line-options.php
+
+Currently, the MiniMagick carrierwave processor provides exactly the same methods as
+for the RMagick processor.
+
+```ruby
+class AvatarUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+
+  process resize_to_fill: [200, 200]
+end
+```
+
+See `carrierwave/processing/mini_magick.rb` for details.
+
+### Using RMagick
+
+CarrierWave also comes with support for RMagick, a well-known image processing library.
+To use it, you'll need to include this in your Uploader:
 
 ```ruby
 class AvatarUploader < CarrierWave::Uploader::Base
@@ -923,7 +995,6 @@ The RMagick module gives you a few methods, like
 way. You can set a `process` callback, which will call that method any time a
 file is uploaded.
 There is a demonstration of convert here.
-Convert will only work if the file has the same file extension, thus the use of the filename method.
 
 ```ruby
 class AvatarUploader < CarrierWave::Uploader::Base
@@ -931,40 +1002,59 @@ class AvatarUploader < CarrierWave::Uploader::Base
 
   process resize_to_fill: [200, 200]
   process convert: 'png'
-
-  def filename
-    super.chomp(File.extname(super)) + '.png' if original_filename.present?
-  end
 end
 ```
 
 Check out the manipulate! method, which makes it easy for you to write your own
 manipulation methods.
 
-## Using MiniMagick
+### Using Vips
 
-MiniMagick is similar to RMagick but performs all the operations using the 'convert'
-CLI which is part of the standard ImageMagick kit. This allows you to have the power
-of ImageMagick without having to worry about installing all the RMagick libraries.
+CarrierWave version 2.2.0 added support for the `libvips` image processing library, through [ImageProcessing::Vips](https://github.com/janko/image_processing/blob/master/doc/vips.md). Its functionality matches that of the RMagick and MiniMagick processors, but it uses less memory and offers [faster processing](https://github.com/libvips/libvips/wiki/Speed-and-memory-use). To use the Vips processing module you must first install `libvips`, for example: 
 
-See the MiniMagick site for more details:
+````bash
+$ sudo apt install libvips
+````
 
-https://github.com/minimagick/minimagick
+You also need to tell your uploader to use Vips:
 
-And the ImageMagick command line options for more for whats on offer:
+````ruby
+class ImageFileUploader < CarrierWave::Uploader::Base
+  include CarrierWave::Vips
+end
+````
 
-http://www.imagemagick.org/script/command-line-options.php
+### List of available processing methods:
 
-Currently, the MiniMagick carrierwave processor provides exactly the same methods as
-for the RMagick processor.
+> [!NOTE]
+> While the intention is to provide uniform interfaces to all three processing libraries the availability and implementation of processing methods can <a href="supported-processing-methods">vary slightly between them</a>.
 
-```ruby
-class AvatarUploader < CarrierWave::Uploader::Base
-  include CarrierWave::MiniMagick
+- `convert` - Changes the image encoding format to the given format (eg. jpg). This operation is treated specially to trigger the change of the file extension, so it matches with the format of the resulting file.
+- `resize_to_limit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. Will only resize the image if it is larger than the specified dimensions. The resulting image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
+- `resize_to_fit` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. The image may be shorter or narrower than specified in the smaller dimension but will not be larger than the specified values.
+- `resize_to_fill` - Resize the image to fit within the specified dimensions while retaining the aspect ratio of the original image. If necessary, crop the image in the larger dimension. Optionally, a "gravity" may be specified, for example "Center", or "NorthEast".
+- `resize_and_pad` - Resize the image to fit within the specified dimensions while retaining the original aspect ratio. If necessary, will pad the remaining area with the given color, which defaults to transparent (for gif and png, white for jpeg). Optionally, a "gravity" may be specified, as above.
+- `crop` - Crop the image to the contents of a box with the specified height and width, positioned a given number of pixels from the top and left. The original image edge will be retained should the bottom and/or right edge of the box fall outside the image bounds. 
 
-  process resize_to_fill: [200, 200]
-end
-```
+#### Supported processing methods
+
+The following table shows which processing methods are supported by each processing library, and which parameters they accept: 
+
+Method|RMagick|MiniMagick|Vips
+------|-----------------|-----------------|-----------------|
+`convert`|`format`|`format`, `page`<sup>1</sup>|`format`, `page`<sup>1</sup>
+`resize_to_limit`|`width`, `height`|`width`, `height`|`width`, `height`
+`resize_to_fit`|`width`, `height`|`width`, `height`|`width`, `height`
+`resize_to_fill`|`width`, `height`, `gravity`<sup>2</sup>|`width`, `height`, `gravity`<sup>2</sup>|`width`, `height`
+`resize_and_pad`|`width`, `height`, `background`, `gravity`<sup>2</sup>|`width`, `height`, `background`, `gravity`<sup>2</sup>|`width`, `height`, `background`, `gravity`<sup>2</sup>
+`resize_to_geometry_string`|`geometry_string`<sup>3</sup>|*not implemented*|*not implemented*
+`crop`|`left`, `top`, `width`, `height`|`left`, `top`, `width`, `height`|`left`, `top`, `width`, `height`
+
+<sup>1</sup>`page` refers to the page number when converting from PDF, frame number when converting from GIF, and layer number when converting from PSD.
+
+<sup>2</sup>`gravity` refers to an image position given as one of `Center`, `North`, `NorthWest`, `West`, `SouthWest`, `South`, `SouthEast`, `East`, or `NorthEast`.
+
+<sup>3</sup>`geometry_string` is an [ImageMagick geometry string](https://rmagick.github.io/imusage.html#geometry).
 
 ## Migrating from Paperclip
 
@@ -1000,10 +1090,13 @@ errors:
     extension_denylist_error: "You are not allowed to upload %{extension} files, prohibited types: %{prohibited_types}"
     content_type_allowlist_error: "You are not allowed to upload %{content_type} files, allowed types: %{allowed_types}"
     content_type_denylist_error: "You are not allowed to upload %{content_type} files"
-    rmagick_processing_error: "Failed to manipulate with rmagick, maybe it is not an image?"
-    mini_magick_processing_error: "Failed to manipulate with MiniMagick, maybe it is not an image? Original Error: %{e}"
+    processing_error: "Failed to manipulate, maybe it is not an image?"
     min_size_error: "File size should be greater than %{min_size}"
     max_size_error: "File size should be less than %{max_size}"
+    min_width_error: "Image width should be greater than %{min_width}px"
+    max_width_error: "Image width should be less than %{max_width}px"
+    min_height_error: "Image height should be greater than %{min_height}px"
+    max_height_error: "Image height should be less than %{max_height}px"
 ```
 
 The [`carrierwave-i18n`](https://github.com/carrierwaveuploader/carrierwave-i18n)
@@ -1066,6 +1159,31 @@ class User
 end
 ```
 
+## Uploader Callbacks
+
+In addition to the ActiveRecord callbacks described above, uploaders also have callbacks.
+
+```ruby
+class MyUploader < ::CarrierWave::Uploader::Base
+  before :remove, :log_removal
+  private
+  def log_removal
+    ::Rails.logger.info(format('Deleting file on S3: %s', @file))
+  end
+end
+```
+
+Uploader callbacks can be `before` or `after` the following events:
+
+```
+cache
+process
+remove
+retrieve_from_cache
+retrieve_from_store
+store
+```
+
 ## Contributing to CarrierWave
 
 See [CONTRIBUTING.md](https://github.com/carrierwaveuploader/carrierwave/blob/master/CONTRIBUTING.md)
@@ -1074,7 +1192,7 @@ See [CONTRIBUTING.md](https://github.com/carrierwaveuploader/carrierwave/blob/ma
 
 The MIT License (MIT)
 
-Copyright (c) 2008-2015 Jonas Nicklas
+Copyright (c) 2008 Jonas Nicklas
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/carrierwave/compatibility/paperclip.rb

@@ -56,10 +56,11 @@ module CarrierWave
         :basename     => lambda{|u, f| u.filename.gsub(/#{File.extname(u.filename)}$/, "") },
         :extension    => lambda{|u, d| File.extname(u.filename).gsub(/^\.+/, "")},
         :class        => lambda{|u, f| u.model.class.name.underscore.pluralize}
-      }
+      }.freeze
 
       included do
         attr_accessor :filename
+
         class_attribute :mappings
         self.mappings ||= DEFAULT_MAPPINGS.dup
       end
@@ -92,7 +93,8 @@ module CarrierWave
         end
       end
 
-      private
+    private
+
       def interpolate_paperclip_path(path)
         mappings.each_pair.inject(path) do |agg, pair|
           agg.gsub(":#{pair[0]}") { pair[1].call(self, self.paperclip_style).to_s }

data/lib/carrierwave/downloader/base.rb

@@ -6,6 +6,8 @@ require 'carrierwave/downloader/remote_file'
 module CarrierWave
   module Downloader
     class Base
+      include CarrierWave::Utilities::Uri
+
       attr_reader :uploader
 
       def initialize(uploader)
@@ -21,6 +23,7 @@ module CarrierWave
       # [remote_headers (Hash)] Request headers
       #
       def download(url, remote_headers = {})
+        @current_download_retry_count = 0
         headers = remote_headers.
           reverse_merge('User-Agent' => "CarrierWave/#{CarrierWave::VERSION}")
         uri = process_uri(url.to_s)
@@ -29,14 +32,26 @@ module CarrierWave
             response = OpenURI.open_uri(process_uri(url.to_s), headers)
           else
             request = nil
-            response = SsrfFilter.get(uri, headers: headers) do |req|
-              request = req
+            if ::SsrfFilter::VERSION.to_f < 1.1
+              response = SsrfFilter.get(uri, headers: headers) do |req|
+                request = req
+              end
+            else
+              response = SsrfFilter.get(uri, headers: headers, request_proc: ->(req) { request = req }) do |res|
+                res.body # ensure to read body
+              end
             end
             response.uri = request.uri
             response.value
           end
         rescue StandardError => e
-          raise CarrierWave::DownloadError, "could not download file: #{e.message}"
+          if @current_download_retry_count < @uploader.download_retry_count
+            @current_download_retry_count += 1
+            sleep @uploader.download_retry_wait_time
+            retry
+          else
+            raise CarrierWave::DownloadError, "could not download file: #{e.message}"
+          end
         end
         CarrierWave::Downloader::RemoteFile.new(response)
       end
@@ -48,17 +63,16 @@ module CarrierWave
       #
       # [url (String)] The URL where the remote file is stored
       #
-      def process_uri(uri)
-        uri_parts = uri.split('?')
-        encoded_uri = Addressable::URI.parse(uri_parts.shift).normalize.to_s
-        query = uri_parts.any? ? "?#{uri_parts.join('?')}" : ''
-        begin
-          URI.parse("#{encoded_uri}#{query}")
-        rescue URI::InvalidURIError
-          URI.parse("#{encoded_uri}#{URI::DEFAULT_PARSER.escape(query)}")
-        end
+      def process_uri(source)
+        uri = Addressable::URI.parse(source)
+        uri.host = uri.normalized_host
+        # Perform decode first, as the path is likely to be already encoded
+        uri.path = encode_path(decode_uri(uri.path)) if uri.path =~ CarrierWave::Utilities::Uri::PATH_UNSAFE
+        uri.query = encode_non_ascii(uri.query) if uri.query
+        uri.fragment = encode_non_ascii(uri.fragment) if uri.fragment
+        URI.parse(uri.to_s)
       rescue URI::InvalidURIError, Addressable::URI::InvalidURIError
-        raise CarrierWave::DownloadError, "couldn't parse URL: #{uri}"
+        raise CarrierWave::DownloadError, "couldn't parse URL: #{source}"
       end
 
       ##
@@ -80,7 +94,7 @@ module CarrierWave
       #     my_uploader.downloader = CarrierWave::Downloader::CustomDownloader
       #
       def skip_ssrf_protection?(uri)
-        false
+        @uploader.skip_ssrf_protection
       end
     end
   end

data/lib/carrierwave/downloader/remote_file.rb

@@ -8,7 +8,10 @@ module CarrierWave
         when String
           @file = StringIO.new(file)
         when Net::HTTPResponse
-          @file = StringIO.new(file.body)
+          body = file.body
+          raise CarrierWave::DownloadError, 'could not download file: No Content' if body.nil?
+
+          @file = StringIO.new(body)
           @content_type = file.content_type
           @headers = file
           @uri = file.uri
@@ -30,18 +33,15 @@ module CarrierWave
 
       def original_filename
         filename = filename_from_header || filename_from_uri
-        mime_type = MiniMime.lookup_by_content_type(content_type)
-        unless File.extname(filename).present? || mime_type.blank?
-          filename = "#{filename}.#{mime_type.extension}"
+        extensions = Marcel::Magic.new(content_type).extensions
+        unless File.extname(filename).present? || extensions.blank?
+          extension = extensions.first
+          filename = "#{filename}.#{extension}"
         end
         filename
       end
 
-      def respond_to?(*args)
-        super || file.respond_to?(*args)
-      end
-
-      private
+    private
 
       def filename_from_header
         return nil unless headers['content-disposition']
@@ -59,7 +59,10 @@ module CarrierWave
       def method_missing(*args, &block)
         file.send(*args, &block)
       end
+
+      def respond_to_missing?(*args)
+        super || file.respond_to?(*args)
+      end
     end
   end
 end
-

data/lib/carrierwave/locale/en.yml

@@ -8,8 +8,10 @@ en:
       extension_denylist_error: "You are not allowed to upload %{extension} files, prohibited types: %{prohibited_types}"
       content_type_allowlist_error: "You are not allowed to upload %{content_type} files, allowed types: %{allowed_types}"
       content_type_denylist_error: "You are not allowed to upload %{content_type} files"
-      rmagick_processing_error: "Failed to manipulate with rmagick, maybe it is not an image?"
-      mini_magick_processing_error: "Failed to manipulate with MiniMagick, maybe it is not an image? Original Error: %{e}"
-      vips_processing_error: "Failed to manipulate with vips, maybe it is not an image? Original Error: %{e}"
+      processing_error: "Failed to manipulate, maybe it is not an image?"
       min_size_error: "File size should be greater than %{min_size}"
       max_size_error: "File size should be less than %{max_size}"
+      min_width_error: "Image width should be greater than %{min_width}px"
+      max_width_error: "Image width should be less than %{max_width}px"
+      min_height_error: "Image height should be greater than %{min_height}px"
+      max_height_error: "Image height should be less than %{max_height}px"