carrierwave 2.0.1 → 2.2.1

data/lib/carrierwave/processing/vips.rb

@@ -0,0 +1,284 @@
+module CarrierWave
+
+  ##
+  # This module simplifies manipulation with vips by providing a set
+  # of convenient helper methods. If you want to use them, you'll need to
+  # require this file:
+  #
+  #     require 'carrierwave/processing/vips'
+  #
+  # And then include it in your uploader:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::Vips
+  #     end
+  #
+  # You can now use the provided helpers:
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::Vips
+  #
+  #       process :resize_to_fit => [200, 200]
+  #     end
+  #
+  # Or create your own helpers with the powerful vips! method, which
+  # yields an ImageProcessing::Builder object. Check out the ImageProcessing
+  # docs at http://github.com/janko-m/image_processing and the list of all
+  # available Vips options at
+  # https://libvips.github.io/libvips/API/current/using-cli.html for more info.
+  #
+  #     class MyUploader < CarrierWave::Uploader::Base
+  #       include CarrierWave::Vips
+  #
+  #       process :radial_blur => 10
+  #
+  #       def radial_blur(amount)
+  #         vips! do |builder|
+  #           builder.radial_blur(amount)
+  #           builder = yield(builder) if block_given?
+  #           builder
+  #         end
+  #       end
+  #     end
+  #
+  # === Note
+  #
+  # The ImageProcessing gem uses ruby-vips, a binding for the vips image
+  # library. You can find more information here:
+  #
+  # https://github.com/libvips/ruby-vips
+  #
+  #
+  module Vips
+    extend ActiveSupport::Concern
+
+    included do
+      require "image_processing/vips"
+      # We need to disable caching since we're editing images in place.
+      ::Vips.cache_set_max(0)
+    end
+
+    module ClassMethods
+      def convert(format)
+        process :convert => format
+      end
+
+      def resize_to_limit(width, height)
+        process :resize_to_limit => [width, height]
+      end
+
+      def resize_to_fit(width, height)
+        process :resize_to_fit => [width, height]
+      end
+
+      def resize_to_fill(width, height, gravity='centre')
+        process :resize_to_fill => [width, height, gravity]
+      end
+
+      def resize_and_pad(width, height, background=nil, gravity='centre', alpha=nil)
+        process :resize_and_pad => [width, height, background, gravity, alpha]
+      end
+    end
+
+    ##
+    # Changes the image encoding format to the given format
+    #
+    # See https://libvips.github.io/libvips/API/current/using-cli.html#using-command-line-conversion
+    #
+    # === Parameters
+    #
+    # [format (#to_s)] an abbreviation of the format
+    #
+    # === Yields
+    #
+    # [Vips::Image] additional manipulations to perform
+    #
+    # === Examples
+    #
+    #     image.convert(:png)
+    #
+    def convert(format, page=nil)
+      vips! do |builder|
+        builder = builder.convert(format)
+        builder = builder.loader(page: page) if page
+        builder
+      end
+    end
+
+    ##
+    # 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.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [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)
+
+      vips! do |builder|
+        builder.resize_to_limit(width, height)
+          .apply(combine_options)
+      end
+    end
+
+    ##
+    # 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.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [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)
+
+      vips! do |builder|
+        builder.resize_to_fit(width, height)
+          .apply(combine_options)
+      end
+    end
+
+    ##
+    # 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.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [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)
+
+      vips! do |builder|
+        builder.resize_to_fill(width, height).apply(combine_options)
+      end
+    end
+
+    ##
+    # 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).
+    #
+    # See https://libvips.github.io/libvips/API/current/libvips-conversion.html#VipsCompassDirection
+    # for gravity options.
+    #
+    # === Parameters
+    #
+    # [width (Integer)] the width to scale the image to
+    # [height (Integer)] the height to scale the image to
+    # [background (List, nil)] the color of the background as a RGB, like [0, 255, 255], nil indicates transparent
+    # [gravity (String)] how to position the image
+    # [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)
+
+      vips! do |builder|
+        builder.resize_and_pad(width, height, background: background, gravity: gravity, alpha: alpha)
+          .apply(combine_options)
+      end
+    end
+
+    ##
+    # Returns the width of the image in pixels.
+    #
+    # === Returns
+    #
+    # [Integer] the image's width in pixels
+    #
+    def width
+      vips_image.width
+    end
+
+    ##
+    # Returns the height of the image in pixels.
+    #
+    # === Returns
+    #
+    # [Integer] the image's height in pixels
+    #
+    def height
+      vips_image.height
+    end
+
+    # Process the image with vip, using the ImageProcessing gem. This
+    # method will build a "convert" vips command and execute it on the
+    # current image.
+    #
+    # === Gotcha
+    #
+    # This method assumes that the object responds to +current_path+.
+    # Any class that this module is mixed into must have a +current_path+ method.
+    # CarrierWave::Uploader does, so you won't need to worry about this in
+    # most cases.
+    #
+    # === Yields
+    #
+    # [ImageProcessing::Builder] use it to define processing to be performed
+    #
+    # === Raises
+    #
+    # [CarrierWave::ProcessingError] if processing failed.
+    def vips!
+      builder = ImageProcessing::Vips.source(current_path)
+      builder = yield(builder)
+
+      result = builder.call
+      result.close
+
+      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 = ::MiniMime.lookup_by_filename(move_to).content_type
+        file.move_to(move_to, permissions, directory_permissions)
+      end
+    rescue ::Vips::Error => e
+      message = I18n.translate(:"errors.messages.vips_processing_error", :e => e)
+      raise CarrierWave::ProcessingError, message
+    end
+
+    private
+
+      def resolve_dimensions(*dimensions)
+        dimensions.map do |value|
+          next value unless value.instance_of?(Proc)
+          value.arity >= 1 ? value.call(self) : value.call
+        end
+      end
+
+      def vips_image
+        ::Vips::Image.new_from_buffer(read, "")
+      end
+
+  end # Vips
+end # CarrierWave

data/lib/carrierwave/sanitized_file.rb

@@ -1,7 +1,7 @@
 require 'pathname'
 require 'active_support/core_ext/string/multibyte'
 require 'mini_mime'
-require 'mimemagic'
+require 'marcel'
 
 module CarrierWave
 
@@ -181,9 +181,9 @@ module CarrierWave
       move!(new_path)
       chmod!(new_path, permissions)
       if keep_filename
-        self.file = {:tempfile => new_path, :filename => original_filename, :content_type => content_type}
+        self.file = {:tempfile => new_path, :filename => original_filename, :content_type => @content_type}
       else
-        self.file = {:tempfile => new_path, :content_type => content_type}
+        self.file = {:tempfile => new_path, :content_type => @content_type}
       end
       self
     end
@@ -261,7 +261,7 @@ module CarrierWave
     def content_type
       @content_type ||=
         existing_content_type ||
-        mime_magic_content_type ||
+        marcel_magic_content_type ||
         mini_mime_content_type
     end
 
@@ -305,7 +305,7 @@ module CarrierWave
     def mkdir!(path, directory_permissions)
       options = {}
       options[:mode] = directory_permissions if directory_permissions
-      FileUtils.mkdir_p(File.dirname(path), options) unless File.exist?(File.dirname(path))
+      FileUtils.mkdir_p(File.dirname(path), **options) unless File.exist?(File.dirname(path))
     end
 
     def chmod!(path, permissions)
@@ -328,11 +328,18 @@ module CarrierWave
       end
     end
 
-    def mime_magic_content_type
+    def marcel_magic_content_type
       if path
-        File.open(path) do |file|
-          MimeMagic.by_magic(file).try(:type) || 'invalid/invalid'
+        type = File.open(path) do |file|
+          Marcel::Magic.by_magic(file).try(:type)
         end
+
+        if type.nil?
+          type = Marcel::Magic.by_path(file).try(:type)
+          type = 'invalid/invalid' unless type.nil? || type.start_with?('text/')
+        end
+
+        type
       end
     rescue Errno::ENOENT
       nil

data/lib/carrierwave/storage/fog.rb

@@ -147,8 +147,9 @@ module CarrierWave
           :public => uploader.fog_public
         ).files.all(:prefix => uploader.cache_dir).each do |file|
           # generate_cache_id returns key formated TIMEINT-PID(-COUNTER)-RND
-          time = file.key.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first.map { |t| t.to_i }
-          time = Time.at(*time)
+          matched = file.key.match(/(\d+)-\d+-\d+(?:-\d+)?/)
+          next unless matched
+          time = Time.at(matched[1].to_i)
           file.destroy if time < (Time.now.utc - seconds)
         end
       end
@@ -161,6 +162,8 @@ module CarrierWave
       end
 
       class File
+        DEFAULT_S3_REGION = 'us-east-1'
+
         include CarrierWave::Utilities::Uri
 
         ##
@@ -194,11 +197,11 @@ module CarrierWave
         # [NilClass] no authenticated url available
         #
         def authenticated_url(options = {})
-          if ['AWS', 'Google', 'Rackspace', 'OpenStack', 'AzureRM', 'Aliyun'].include?(@uploader.fog_credentials[:provider])
+          if ['AWS', 'Google', 'Rackspace', 'OpenStack', 'AzureRM', 'Aliyun', 'backblaze'].include?(@uploader.fog_credentials[:provider])
             # avoid a get by using local references
             local_directory = connection.directories.new(:key => @uploader.fog_directory)
             local_file = local_directory.files.new(:key => path)
-            expire_at = options[:expire_at] || ::Fog::Time.now + @uploader.fog_authenticated_url_expiration
+            expire_at = options[:expire_at] || ::Fog::Time.now.since(@uploader.fog_authenticated_url_expiration.to_i)
             case @uploader.fog_credentials[:provider]
               when 'AWS', 'Google'
                 # Older versions of fog-google do not support options as a parameter
@@ -384,9 +387,15 @@ module CarrierWave
                 if valid_subdomain
                   s3_subdomain = @uploader.fog_aws_accelerate ? "s3-accelerate" : "s3"
                   "#{protocol}://#{@uploader.fog_directory}.#{s3_subdomain}.amazonaws.com/#{encoded_path}"
-                else
-                  # directory is not a valid subdomain, so use path style for access
-                  "#{protocol}://s3.amazonaws.com/#{@uploader.fog_directory}/#{encoded_path}"
+                else # directory is not a valid subdomain, so use path style for access
+                  region = @uploader.fog_credentials[:region].to_s
+                  host   = case region
+                           when DEFAULT_S3_REGION, ''
+                             's3.amazonaws.com'
+                           else
+                             "s3.#{region}.amazonaws.com"
+                           end
+                  "#{protocol}://#{host}/#{@uploader.fog_directory}/#{encoded_path}"
                 end
               end
             when 'Google'
@@ -442,7 +451,7 @@ module CarrierWave
         # @return [CarrierWave::Storage::Fog::File] the location where the file will be stored.
         #
         def copy_to(new_path)
-          connection.copy_object(@uploader.fog_directory, file.key, @uploader.fog_directory, new_path, acl_header)
+          connection.copy_object(@uploader.fog_directory, file.key, @uploader.fog_directory, new_path, copy_options)
           CarrierWave::Storage::Fog::File.new(@uploader, @base, new_path)
         end
 
@@ -486,9 +495,18 @@ module CarrierWave
           @file ||= directory.files.head(path)
         end
 
+        def copy_options
+          options = {}
+          options.merge!(acl_header) if acl_header.present?
+          options['Content-Type'] ||= content_type if content_type
+          options.merge(@uploader.fog_attributes)
+        end
+
         def acl_header
           if fog_provider == 'AWS'
             { 'x-amz-acl' => @uploader.fog_public ? 'public-read' : 'private' }
+          elsif fog_provider == "Google"
+            @uploader.fog_public ? { destination_predefined_acl: "publicRead" } : {}
           else
             {}
           end

data/lib/carrierwave/uploader/cache.rb

@@ -76,7 +76,7 @@ module CarrierWave
       # [Bool] whether the current file is cached
       #
       def cached?
-        @cache_id
+        !!@cache_id
       end
 
       ##

data/lib/carrierwave/uploader/content_type_blacklist.rb

@@ -8,39 +8,48 @@ module CarrierWave
       end
 
       ##
-      # Override this method in your uploader to provide a blacklist of files content types
+      # Override this method in your uploader to provide a denylist of files content types
       # which are not allowed to be uploaded.
       # Not only strings but Regexp are allowed as well.
       #
       # === Returns
       #
-      # [NilClass, String, Regexp, Array[String, Regexp]] a blacklist of content types which are not allowed to be uploaded
+      # [NilClass, String, Regexp, Array[String, Regexp]] a denylist of content types which are not allowed to be uploaded
       #
       # === Examples
       #
-      #     def content_type_blacklist
+      #     def content_type_denylist
       #       %w(text/json application/json)
       #     end
       #
       # Basically the same, but using a Regexp:
       #
-      #     def content_type_blacklist
+      #     def content_type_denylist
       #       [/(text|application)\/json/]
       #     end
       #
-      def content_type_blacklist; end
+      def content_type_denylist
+        if respond_to?(:content_type_blacklist)
+          ActiveSupport::Deprecation.warn "#content_type_blacklist is deprecated, use #content_type_denylist instead." unless instance_variable_defined?(:@content_type_blacklist_warned)
+          @content_type_blacklist_warned = true
+          content_type_blacklist
+        end
+      end
 
     private
 
       def check_content_type_blacklist!(new_file)
+        return unless content_type_denylist
+
         content_type = new_file.content_type
-        if content_type_blacklist && blacklisted_content_type?(content_type)
-          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.content_type_blacklist_error", content_type: content_type)
+        if blacklisted_content_type?(content_type)
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.content_type_blacklist_error",
+                                                            content_type: content_type, default: :"errors.messages.content_type_denylist_error")
         end
       end
 
       def blacklisted_content_type?(content_type)
-        Array(content_type_blacklist).any? { |item| content_type =~ /#{item}/ }
+        Array(content_type_denylist).any? { |item| content_type =~ /#{item}/ }
       end
 
     end # ContentTypeBlacklist