carrierwave 0.9.0 → 2.1.1

data/lib/carrierwave/mounter.rb

@@ -0,0 +1,188 @@
+module CarrierWave
+
+  # this is an internal class, used by CarrierWave::Mount so that
+  # we don't pollute the model with a lot of methods.
+  class Mounter #:nodoc:
+    attr_reader :column, :record, :remote_urls, :integrity_errors,
+      :processing_errors, :download_errors
+    attr_accessor :remove, :remote_request_headers
+
+    def initialize(record, column, options={})
+      @record = record
+      @column = column
+      @options = record.class.uploader_options[column]
+      @download_errors = []
+      @processing_errors = []
+      @integrity_errors = []
+    end
+
+    def uploader_class
+      record.class.uploaders[column]
+    end
+
+    def blank_uploader
+      uploader_class.new(record, column)
+    end
+
+    def identifiers
+      uploaders.map(&:identifier)
+    end
+
+    def read_identifiers
+      [record.read_uploader(serialization_column)].flatten.reject(&:blank?)
+    end
+
+    def uploaders
+      @uploaders ||= read_identifiers.map do |identifier|
+        uploader = blank_uploader
+        uploader.retrieve_from_store!(identifier) if identifier.present?
+        uploader
+      end
+    end
+
+    def cache(new_files)
+      return if !new_files.is_a?(Array) && new_files.blank?
+      old_uploaders = uploaders
+      @uploaders = new_files.map do |new_file|
+        handle_error do
+          if new_file.is_a?(String)
+            if (uploader = old_uploaders.detect { |uploader| uploader.identifier == new_file })
+              uploader.staged = true
+              uploader
+            else
+              begin
+                uploader = blank_uploader
+                uploader.retrieve_from_cache!(new_file)
+                uploader
+              rescue CarrierWave::InvalidParameter
+                nil
+              end
+            end
+          else
+            uploader = blank_uploader
+            uploader.cache!(new_file)
+            uploader
+          end
+        end
+      end.compact
+    end
+
+    def cache_names
+      uploaders.map(&:cache_name).compact
+    end
+
+    def cache_names=(cache_names)
+      cache_names = cache_names.reject(&:blank?)
+      return if cache_names.blank?
+      clear_unstaged
+      cache_names.each do |cache_name|
+        begin
+          uploader = blank_uploader
+          uploader.retrieve_from_cache!(cache_name)
+          @uploaders << uploader
+        rescue CarrierWave::InvalidParameter
+          # ignore
+        end
+      end
+    end
+
+    def remote_urls=(urls)
+      return if urls.blank? || urls.all?(&:blank?)
+
+      @remote_urls = urls
+
+      clear_unstaged
+      urls.zip(remote_request_headers || []).each do |url, header|
+        handle_error do
+          uploader = blank_uploader
+          uploader.download!(url, header || {})
+          @uploaders << uploader
+        end
+      end
+    end
+
+    def store!
+      uploaders.reject(&:blank?).each(&:store!)
+    end
+
+    def urls(*args)
+      uploaders.map { |u| u.url(*args) }
+    end
+
+    def blank?
+      uploaders.none?(&:present?)
+    end
+
+    def remove?
+      remove.present? && (remove == true || remove !~ /\A0|false$\z/)
+    end
+
+    def remove!
+      uploaders.reject(&:blank?).each(&:remove!)
+      @uploaders = []
+    end
+
+    def clear!
+      @uploaders = []
+    end
+
+    def serialization_column
+      option(:mount_on) || column
+    end
+
+    def remove_previous(before=nil, after=nil)
+      after ||= []
+      return unless before
+
+      # both 'before' and 'after' can be string when 'mount_on' option is set
+      before = before.reject(&:blank?).map do |value|
+        if value.is_a?(String)
+          uploader = blank_uploader
+          uploader.retrieve_from_store!(value)
+          uploader
+        else
+          value
+        end
+      end
+      after_paths = after.reject(&:blank?).map do |value|
+        if value.is_a?(String)
+          uploader = blank_uploader
+          uploader.retrieve_from_store!(value)
+          uploader
+        else
+          value
+        end.path
+      end
+      before.each do |uploader|
+        uploader.remove! if uploader.remove_previously_stored_files_after_update && !after_paths.include?(uploader.path)
+      end
+    end
+
+    attr_accessor :uploader_options
+
+  private
+
+    def option(name)
+      self.uploader_options ||= {}
+      self.uploader_options[name] ||= record.class.uploader_option(column, name)
+    end
+
+    def clear_unstaged
+      @uploaders ||= []
+      @uploaders.keep_if(&:staged)
+    end
+
+    def handle_error
+      yield
+    rescue CarrierWave::DownloadError => e
+      @download_errors << e
+      raise e unless option(:ignore_download_errors)
+    rescue CarrierWave::ProcessingError => e
+      @processing_errors << e
+      raise e unless option(:ignore_processing_errors)
+    rescue CarrierWave::IntegrityError => e
+      @integrity_errors << e
+      raise e unless option(:ignore_integrity_errors)
+    end
+  end # Mounter
+end # CarrierWave

data/lib/carrierwave/orm/activerecord.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'active_record'
 require 'carrierwave/validations/active_model'
 
@@ -14,6 +12,39 @@ module CarrierWave
     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)
+          column = _mounter(:#{column}).serialization_column
+          __send__(:"\#{column}_will_change!")
+          super
+        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=(url)
+          column = _mounter(:#{column}).serialization_column
+          __send__(:"\#{column}_will_change!")
+          super
+        end
+      RUBY
+    end
+
+  private
+
+    def mount_base(column, uploader=nil, options={}, &block)
+      super
+
       alias_method :read_uploader, :read_attribute
       alias_method :write_uploader, :write_attribute
       public :read_uploader
@@ -25,46 +56,51 @@ module CarrierWave
       validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
       validates_download_of column if uploader_option(column.to_sym, :validate_download)
 
-      after_save :"store_#{column}!"
       before_save :"write_#{column}_identifier"
+      after_save :"store_previous_changes_for_#{column}"
       after_commit :"remove_#{column}!", :on => :destroy
-      before_update :"store_previous_model_for_#{column}"
-      after_save :"remove_previously_stored_#{column}"
+      after_commit :"mark_remove_#{column}_false", :on => :update
+      after_commit :"remove_previously_stored_#{column}", :on => :update
+      after_commit :"store_#{column}!", :on => [:create, :update]
 
-      class_eval <<-RUBY, __FILE__, __LINE__+1
+      mod = Module.new
+      prepend mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
         def #{column}=(new_file)
           column = _mounter(:#{column}).serialization_column
-          send(:"\#{column}_will_change!")
+          if !(new_file.blank? && __send__(:#{column}).blank?)
+            __send__(:"\#{column}_will_change!")
+          end
+
           super
         end
 
-        def remote_#{column}_url=(url)
+        def remove_#{column}=(value)
           column = _mounter(:#{column}).serialization_column
-          send(:"\#{column}_will_change!")
-          super
+          result = super
+          __send__(:"\#{column}_will_change!") if _mounter(:#{column}).remove?
+          result
         end
 
         def remove_#{column}!
+          self.remove_#{column} = true
+          write_#{column}_identifier
+          self.remove_#{column} = false
           super
-          _mounter(:#{column}).remove = true
-          _mounter(:#{column}).write_identifier
         end
 
-        def serializable_hash(options=nil)
-          hash = {}
-
-          except = options && options[:except] && Array.wrap(options[:except]).map(&:to_s)
-          only   = options && options[:only]   && Array.wrap(options[:only]).map(&:to_s)
+        # Reset cached mounter on record reload
+        def reload(*)
+          @_mounters = nil
+          super
+        end
 
-          self.class.uploaders.each do |column, uploader|
-            if (!only && !except) || (only && only.include?(column.to_s)) || (!only && except && !except.include?(column.to_s))
-              hash[column.to_s] = _mounter(column).uploader.serializable_hash
-            end
-          end
-          super(options).merge(hash)
+        # Reset cached mounter on record dup
+        def initialize_dup(other)
+          @_mounters = nil
+          super
         end
       RUBY
-
     end
 
   end # ActiveRecord

data/lib/carrierwave/processing/mini_magick.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
 
   ##
@@ -23,9 +21,11 @@ module CarrierWave
   #       process :resize_to_fit => [200, 200]
   #     end
   #
-  # Or create your own helpers with the powerful manipulate! method. Check
-  # out the ImageMagick docs at http://www.imagemagick.org/script/command-line-options.php for more
-  # info
+  # Or create your own helpers with the powerful minimagick! 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 ImageMagick options at
+  # http://www.imagemagick.org/script/command-line-options.php for more info.
   #
   #     class MyUploader < CarrierWave::Uploader::Base
   #       include CarrierWave::MiniMagick
@@ -33,35 +33,30 @@ module CarrierWave
   #       process :radial_blur => 10
   #
   #       def radial_blur(amount)
-  #         manipulate! do |img|
-  #           img.radial_blur(amount)
-  #           img = yield(img) if block_given?
-  #           img
+  #         minimagick! do |builder|
+  #           builder.radial_blur(amount)
+  #           builder = yield(builder) if block_given?
+  #           builder
   #         end
   #       end
+  #     end
   #
   # === Note
   #
-  # MiniMagick is a mini replacement for RMagick that uses the command line
-  # tool "mogrify" for image manipulation.
+  # The ImageProcessing gem uses MiniMagick, a mini replacement for RMagick
+  # that uses ImageMagick command-line tools, to build a "convert" command that
+  # performs the processing.
   #
   # You can find more information here:
   #
-  # http://mini_magick.rubyforge.org/
-  # and
-  # https://github.com/minimagic/minimagick/
+  # https://github.com/minimagick/minimagick/
   #
   #
   module MiniMagick
     extend ActiveSupport::Concern
 
     included do
-      begin
-        require "mini_magick"
-      rescue LoadError => e
-        e.message << " (You may need to install the mini_magick gem)"
-        raise e
-      end
+      require "image_processing/mini_magick"
     end
 
     module ClassMethods
@@ -81,7 +76,7 @@ module CarrierWave
         process :resize_to_fill => [width, height, gravity]
       end
 
-      def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity)
+      def resize_and_pad(width, height, background=:transparent, gravity='Center')
         process :resize_and_pad => [width, height, background, gravity]
       end
     end
@@ -103,12 +98,11 @@ module CarrierWave
     #
     #     image.convert(:png)
     #
-    def convert(format)
-      @format = format
-      manipulate! do |img|
-        img.format(format.to_s.downcase)
-        img = yield(img) if block_given?
-        img
+    def convert(format, page=nil, &block)
+      minimagick!(block) do |builder|
+        builder = builder.convert(format)
+        builder = builder.loader(page: page) if page
+        builder
       end
     end
 
@@ -122,16 +116,18 @@ module CarrierWave
     #
     # [width (Integer)] the width to scale the image to
     # [height (Integer)] the height to scale the image to
+    # [combine_options (Hash)] additional ImageMagick options to apply before resizing
     #
     # === Yields
     #
     # [MiniMagick::Image] additional manipulations to perform
     #
-    def resize_to_limit(width, height)
-      manipulate! do |img|
-        img.resize "#{width}x#{height}>"
-        img = yield(img) if block_given?
-        img
+    def resize_to_limit(width, height, combine_options: {}, &block)
+      width, height = resolve_dimensions(width, height)
+
+      minimagick!(block) do |builder|
+        builder.resize_to_limit(width, height)
+          .apply(combine_options)
       end
     end
 
@@ -144,16 +140,18 @@ module CarrierWave
     #
     # [width (Integer)] the width to scale the image to
     # [height (Integer)] the height to scale the image to
+    # [combine_options (Hash)] additional ImageMagick options to apply before resizing
     #
     # === Yields
     #
     # [MiniMagick::Image] additional manipulations to perform
     #
-    def resize_to_fit(width, height)
-      manipulate! do |img|
-        img.resize "#{width}x#{height}"
-        img = yield(img) if block_given?
-        img
+    def resize_to_fit(width, height, combine_options: {}, &block)
+      width, height = resolve_dimensions(width, height)
+
+      minimagick!(block) do |builder|
+        builder.resize_to_fit(width, height)
+          .apply(combine_options)
       end
     end
 
@@ -167,34 +165,18 @@ module CarrierWave
     # [width (Integer)] the width to scale the image to
     # [height (Integer)] the height to scale the image to
     # [gravity (String)] the current gravity suggestion (default: 'Center'; options: 'NorthWest', 'North', 'NorthEast', 'West', 'Center', 'East', 'SouthWest', 'South', 'SouthEast')
+    # [combine_options (Hash)] additional ImageMagick options to apply before resizing
     #
     # === Yields
     #
     # [MiniMagick::Image] additional manipulations to perform
     #
-    def resize_to_fill(width, height, gravity = 'Center')
-      manipulate! do |img|
-        cols, rows = img[:dimensions]
-        img.combine_options do |cmd|
-          if width != cols || height != rows
-            scale_x = width/cols.to_f
-            scale_y = height/rows.to_f
-            if scale_x >= scale_y
-              cols = (scale_x * (cols + 0.5)).round
-              rows = (scale_x * (rows + 0.5)).round
-              cmd.resize "#{cols}"
-            else
-              cols = (scale_y * (cols + 0.5)).round
-              rows = (scale_y * (rows + 0.5)).round
-              cmd.resize "x#{rows}"
-            end
-          end
-          cmd.gravity gravity
-          cmd.background "rgba(255,255,255,0.0)"
-          cmd.extent "#{width}x#{height}" if cols != width || rows != height
-        end
-        img = yield(img) if block_given?
-        img
+    def resize_to_fill(width, height, gravity = 'Center', combine_options: {}, &block)
+      width, height = resolve_dimensions(width, height)
+
+      minimagick!(block) do |builder|
+        builder.resize_to_fill(width, height, gravity: gravity)
+          .apply(combine_options)
       end
     end
 
@@ -213,33 +195,51 @@ module CarrierWave
     # [height (Integer)] the height to scale the image to
     # [background (String, :transparent)] the color of the background as a hexcode, like "#ff45de"
     # [gravity (String)] how to position the image
+    # [combine_options (Hash)] additional ImageMagick options to apply before resizing
     #
     # === Yields
     #
     # [MiniMagick::Image] additional manipulations to perform
     #
-    def resize_and_pad(width, height, background=:transparent, gravity='Center')
-      manipulate! do |img|
-        img.combine_options do |cmd|
-          cmd.thumbnail "#{width}x#{height}>"
-          if background == :transparent
-            cmd.background "rgba(255, 255, 255, 0.0)"
-          else
-            cmd.background background
-          end
-          cmd.gravity gravity
-          cmd.extent "#{width}x#{height}"
-        end
-        img = yield(img) if block_given?
-        img
+    def resize_and_pad(width, height, background=:transparent, gravity='Center', combine_options: {}, &block)
+      width, height = resolve_dimensions(width, height)
+
+      minimagick!(block) do |builder|
+        builder.resize_and_pad(width, height, background: background, gravity: gravity)
+          .apply(combine_options)
       end
     end
 
+    ##
+    # Returns the width of the image in pixels.
+    #
+    # === Returns
+    #
+    # [Integer] the image's width in pixels
+    #
+    def width
+      mini_magick_image[:width]
+    end
+
+    ##
+    # Returns the height of the image in pixels.
+    #
+    # === Returns
+    #
+    # [Integer] the image's height in pixels
+    #
+    def height
+      mini_magick_image[:height]
+    end
+
     ##
     # Manipulate the image with MiniMagick. This method will load up an image
     # and then pass each of its frames to the supplied block. It will then
     # save the image to disk.
     #
+    # NOTE: This method exists mostly for backwards compatibility, you should
+    # probably use #minimagick!.
+    #
     # === Gotcha
     #
     # This method assumes that the object responds to +current_path+.
@@ -258,13 +258,74 @@ module CarrierWave
     def manipulate!
       cache_stored_file! if !cached?
       image = ::MiniMagick::Image.open(current_path)
-      image.format(@format.to_s.downcase) if @format
+
       image = yield(image)
-      image.write(current_path)
-      ::MiniMagick::Image.open(current_path)
+      FileUtils.mv image.path, current_path
+
+      image.run_command("identify", current_path)
+    rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
+      message = I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e)
+      raise CarrierWave::ProcessingError, message
+    ensure
+      image.destroy! if image
+    end
+
+    # Process the image with MiniMagick, using the ImageProcessing gem. This
+    # method will build a "convert" ImageMagick 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 minimagick!(block = nil)
+      builder = ImageProcessing::MiniMagick.source(current_path)
+      builder = yield(builder)
+
+      result = builder.call
+      result.close
+
+      # backwards compatibility (we want to eventually move away from MiniMagick::Image)
+      if block
+        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 = ::MiniMime.lookup_by_filename(move_to).content_type
+        file.move_to(move_to, permissions, directory_permissions)
+      end
     rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
-      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e, :default => I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e, :locale => :en))
+      message = I18n.translate(:"errors.messages.mini_magick_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 mini_magick_image
+        ::MiniMagick::Image.read(read)
+      end
+
   end # MiniMagick
 end # CarrierWave