carrierwave 1.3.4 → 3.1.4

data/lib/carrierwave/processing/vips.rb

@@ -0,0 +1,315 @@
+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
+
+      def crop(left, top, width, height)
+        process :crop => [left, top, width, height]
+      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
+
+    ##
+    # Crop the image to the contents of a box positioned at [left] and [top], with the dimensions given
+    # by [width] and [height]. The original image bottom/right edge is preserved if the cropping box falls
+    # outside the image bounds.
+    #
+    # === Parameters
+    #
+    # [left (integer)] left edge of area to extract
+    # [top (integer)] top edge of area to extract
+    # [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
+      height = vips_image.height - top if height + top > vips_image.height
+
+      vips! do |builder|
+        builder.crop(left, top, width, height)
+          .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 = Marcel::Magic.by_path(move_to).try(:type)
+        file.move_to(move_to, permissions, directory_permissions)
+      end
+    rescue ::Vips::Error
+      message = I18n.translate(:"errors.messages.processing_error")
+      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/processing.rb

@@ -1,2 +1,3 @@
 require "carrierwave/processing/rmagick"
 require "carrierwave/processing/mini_magick"
+require "carrierwave/processing/vips"

data/lib/carrierwave/sanitized_file.rb

@@ -1,12 +1,5 @@
 require 'pathname'
-require 'active_support/core_ext/string/multibyte'
-
-begin
-  # Use mime/types/columnar if available, for reduced memory usage
-  require 'mime/types/columnar'
-rescue LoadError
-  require 'mime/types'
-end
+require 'marcel'
 
 module CarrierWave
 
@@ -19,6 +12,7 @@ module CarrierWave
   # It's probably needlessly comprehensive and complex. Help is appreciated.
   #
   class SanitizedFile
+    include CarrierWave::Utilities::FileName
 
     attr_reader :file
 
@@ -32,7 +26,7 @@ module CarrierWave
 
     def initialize(file)
       self.file = file
-      @content = nil
+      @content = @content_type = nil
     end
 
     ##
@@ -44,7 +38,7 @@ module CarrierWave
     #
     def original_filename
       return @original_filename if @original_filename
-      if @file and @file.respond_to?(:original_filename)
+      if @file && @file.respond_to?(:original_filename)
         @file.original_filename
       elsif path
         File.basename(path)
@@ -64,29 +58,6 @@ module CarrierWave
 
     alias_method :identifier, :filename
 
-    ##
-    # Returns the part of the filename before the extension. So if a file is called 'test.jpeg'
-    # this would return 'test'
-    #
-    # === Returns
-    #
-    # [String] the first part of the filename
-    #
-    def basename
-      split_extension(filename)[0] if filename
-    end
-
-    ##
-    # Returns the file extension
-    #
-    # === Returns
-    #
-    # [String] the extension
-    #
-    def extension
-      split_extension(filename)[1] if filename
-    end
-
     ##
     # Returns the file's size.
     #
@@ -137,7 +108,7 @@ module CarrierWave
     # [Boolean] whether the file is valid and has a non-zero size
     #
     def empty?
-      @file.nil? || self.size.nil? || (self.size.zero? && ! self.exists?)
+      @file.nil? || self.size.nil? || (self.size.zero? && !self.exists?)
     end
 
     ##
@@ -156,19 +127,36 @@ module CarrierWave
     #
     # [String] contents of the file
     #
-    def read
-      if @content
-        @content
-      elsif is_path?
-        File.open(@file, "rb") {|file| file.read}
+    def read(*args)
+      if args.empty?
+        if @content
+          @content
+        elsif is_path?
+          File.open(@file, "rb") {|file| file.read }
+        else
+          @file.try(:rewind)
+          @content = @file.read
+          @file.try(:close) unless @file.class.ancestors.include?(::StringIO) || @file.try(:closed?)
+          @content
+        end
       else
-        @file.try(:rewind)
-        @content = @file.read
-        @file.try(:close) unless @file.try(:closed?)
-        @content
+        if is_path?
+          @file = File.open(path, "rb")
+        elsif @file.is_a?(CarrierWave::Uploader::Base)
+          @file = StringIO.new(@file.read)
+        end
+
+        @file.read(*args)
       end
     end
 
+    ##
+    # Rewinds the underlying file.
+    #
+    def rewind
+      @file.rewind if @file.respond_to?(:rewind)
+    end
+
     ##
     # Moves the file to the given path
     #
@@ -185,13 +173,10 @@ module CarrierWave
       mkdir!(new_path, directory_permissions)
       move!(new_path)
       chmod!(new_path, permissions)
-      if keep_filename
-        self.file = {:tempfile => new_path, :filename => original_filename, :content_type => content_type}
-      else
-        self.file = {:tempfile => new_path, :content_type => content_type}
-      end
+      self.file = {tempfile: new_path, filename: keep_filename ? original_filename : nil, content_type: declared_content_type}
       self
     end
+
     ##
     # Helper to move file to new path.
     #
@@ -223,7 +208,7 @@ module CarrierWave
       mkdir!(new_path, directory_permissions)
       copy!(new_path)
       chmod!(new_path, permissions)
-      self.class.new({:tempfile => new_path, :content_type => content_type})
+      self.class.new({tempfile: new_path, content_type: declared_content_type})
     end
 
     ##
@@ -264,12 +249,11 @@ module CarrierWave
     # [String] the content type of the file
     #
     def content_type
-      return @content_type if @content_type
-      if @file.respond_to?(:content_type) and @file.content_type
-        @content_type = @file.content_type.to_s.chomp
-      elsif path
-        @content_type = ::MIME::Types.type_for(path).first.to_s
-      end
+      @content_type ||=
+        identified_content_type ||
+        declared_content_type ||
+        guessed_safe_content_type ||
+        Marcel::MimeType::BINARY
     end
 
     ##
@@ -300,11 +284,11 @@ module CarrierWave
       if file.is_a?(Hash)
         @file = file["tempfile"] || file[:tempfile]
         @original_filename = file["filename"] || file[:filename]
-        @content_type = file["content_type"] || file[:content_type] || file["type"] || file[:type]
+        @declared_content_type = file["content_type"] || file[:content_type] || file["type"] || file[:type]
       else
         @file = file
         @original_filename = nil
-        @content_type = nil
+        @declared_content_type = nil
       end
     end
 
@@ -321,28 +305,65 @@ module CarrierWave
 
     # Sanitize the filename, to prevent hacking
     def sanitize(name)
+      name = name.scrub
       name = name.tr("\\", "/") # work-around for IE
       name = File.basename(name)
-      name = name.gsub(sanitize_regexp,"_")
+      name = name.gsub(sanitize_regexp, "_")
       name = "_#{name}" if name =~ /\A\.+\z/
-      name = "unnamed" if name.size == 0
-      return name.mb_chars.to_s
+      name = "unnamed" if name.size.zero?
+      name.to_s
+    end
+
+    def declared_content_type
+      @declared_content_type ||
+        if @file.respond_to?(:content_type) && @file.content_type
+          Marcel::MimeType.for(declared_type: first_declared_content_type(@file.content_type))
+        end
     end
 
-    def split_extension(filename)
-      # regular expressions to try for identifying extensions
-      extension_matchers = [
-        /\A(.+)\.(tar\.([glx]?z|bz2))\z/, # matches "something.tar.gz"
-        /\A(.+)\.([^\.]+)\z/ # matches "something.jpg"
-      ]
+    # Clients occasionally send more than one MIME type in a single header
+    # (e.g. "image/png; text/html" or "image/png, text/html"). Marcel 2 validates
+    # the declared type against the RFC grammar and rejects such values, so pick
+    # the first media type ourselves before handing it over.
+    def first_declared_content_type(content_type)
+      content_type.to_s.strip.split(/[;,\s]/, 2).first
+    end
+
+    # Guess content type from its file extension. Limit what to be returned to prevent spoofing.
+    def guessed_safe_content_type
+      return unless path
+
+      type = Marcel::Magic.by_path(original_filename).to_s
+      type if type.start_with?('text/') || type.start_with?('application/json')
+    end
+
+    def identified_content_type
+      with_io do |io|
+        mimetype_by_magic = Marcel::Magic.by_magic(io)
+        mimetype_by_path = Marcel::Magic.by_path(path)
 
-      extension_matchers.each do |regexp|
-        if filename =~ regexp
-          return $1, $2
+        return nil if mimetype_by_magic.nil?
+
+        if mimetype_by_path&.child_of?(mimetype_by_magic.type)
+          mimetype_by_path.type
+        else
+          mimetype_by_magic.type
         end
       end
-      return filename, "" # In case we weren't able to split the extension
+    rescue Errno::ENOENT
+      nil
     end
 
+    def with_io(&block)
+      if file.is_a?(IO)
+        begin
+          yield file
+        ensure
+          file.try(:rewind)
+        end
+      elsif path
+        File.open(path, &block)
+      end
+    end
   end # SanitizedFile
 end # CarrierWave

data/lib/carrierwave/storage/abstract.rb

@@ -14,7 +14,7 @@ module CarrierWave
       end
 
       def identifier
-        uploader.filename
+        uploader.deduplicated_filename
       end
 
       def store!(file)
@@ -24,19 +24,19 @@ module CarrierWave
       end
 
       def cache!(new_file)
-        raise NotImplementedError.new("Need to implement #cache! if you want to use #{self.class.name} as a cache storage.")
+        raise NotImplementedError, "Need to implement #cache! if you want to use #{self.class.name} as a cache storage."
       end
 
       def retrieve_from_cache!(identifier)
-        raise NotImplementedError.new("Need to implement #retrieve_from_cache! if you want to use #{self.class.name} as a cache storage.")
+        raise NotImplementedError, "Need to implement #retrieve_from_cache! if you want to use #{self.class.name} as a cache storage."
       end
 
       def delete_dir!(path)
-        raise NotImplementedError.new("Need to implement #delete_dir! if you want to use #{self.class.name} as a cache storage.")
+        raise NotImplementedError, "Need to implement #delete_dir! if you want to use #{self.class.name} as a cache storage."
       end
 
       def clean_cache!(seconds)
-        raise NotImplementedError.new("Need to implement #clean_cache! if you want to use #{self.class.name} as a cache storage.")
+        raise NotImplementedError, "Need to implement #clean_cache! if you want to use #{self.class.name} as a cache storage."
       end
     end # Abstract
   end # Storage

data/lib/carrierwave/storage/file.rb

@@ -17,7 +17,7 @@ module CarrierWave
       #
       # By default, store!() uses copy_to(), which operates by copying the file
       # from the cache to the store, then deleting the file from the cache.
-      # If move_to_store() is overriden to return true, then store!() uses move_to(),
+      # If move_to_store() is overridden to return true, then store!() uses move_to(),
       # which simply moves the file from cache to store.  Useful for large files.
       #
       # === Parameters
@@ -109,10 +109,11 @@ module CarrierWave
       end
 
       def clean_cache!(seconds)
-        Dir.glob(::File.expand_path(::File.join(uploader.cache_dir, '*'), CarrierWave.root)).each do |dir|
-          # generate_cache_id returns key formated TIMEINT-PID-COUNTER-RND
-          time = dir.scan(/(\d+)-\d+-\d+-\d+/).first.map(&:to_i)
-          time = Time.at(*time)
+        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)
           if time < (Time.now.utc - seconds)
             FileUtils.rm_rf(dir)
           end