carrierwave 2.2.4 → 3.0.1

data/lib/carrierwave/mounter.rb

@@ -2,18 +2,49 @@ 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
+  class Mounter # :nodoc:
+    class Single < Mounter # :nodoc
+      def identifier
+        uploaders.first&.identifier
+      end
+
+      def temporary_identifier
+        temporary_identifiers.first
+      end
+    end
+
+    class Multiple < Mounter # :nodoc
+      def identifier
+        uploaders.map(&:identifier).presence
+      end
+
+      def temporary_identifier
+        temporary_identifiers.presence
+      end
+    end
+
+    def self.build(record, column)
+      if record.class.uploader_options[column][:multiple]
+        Multiple.new(record, column)
+      else
+        Single.new(record, column)
+      end
+    end
+
+    attr_reader :column, :record, :remote_urls, :remove,
+                :integrity_errors, :processing_errors, :download_errors
+    attr_accessor :remote_request_headers, :uploader_options
 
-    def initialize(record, column, options={})
+    def initialize(record, column)
       @record = record
       @column = column
       @options = record.class.uploader_options[column]
       @download_errors = []
       @processing_errors = []
       @integrity_errors = []
+
+      @removed_uploaders = []
+      @added_uploaders = []
     end
 
     def uploader_class
@@ -35,7 +66,7 @@ module CarrierWave
     def uploaders
       @uploaders ||= read_identifiers.map do |identifier|
         uploader = blank_uploader
-        uploader.retrieve_from_store!(identifier) if identifier.present?
+        uploader.retrieve_from_store!(identifier)
         uploader
       end
     end
@@ -46,7 +77,7 @@ module CarrierWave
       @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 })
+            if (uploader = old_uploaders.detect { |old_uploader| old_uploader.identifier == new_file })
               uploader.staged = true
               uploader
             else
@@ -64,7 +95,9 @@ module CarrierWave
             uploader
           end
         end
-      end.compact
+      end.reject(&:blank?)
+      @removed_uploaders += (old_uploaders - @uploaders)
+      write_temporary_identifier
     end
 
     def cache_names
@@ -76,33 +109,51 @@ module CarrierWave
       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
+        uploader = blank_uploader
+        uploader.retrieve_from_cache!(cache_name)
+        @uploaders << uploader
+      rescue CarrierWave::InvalidParameter
+        # ignore
       end
+      write_temporary_identifier
     end
 
     def remote_urls=(urls)
-      return if urls.blank? || urls.all?(&:blank?)
-
+      if urls.nil?
+        urls = []
+      else
+        urls = Array.wrap(urls).reject(&:blank?)
+        return if urls.blank?
+      end
       @remote_urls = urls
 
       clear_unstaged
-      urls.zip(remote_request_headers || []).each do |url, header|
+      @remote_urls.zip(remote_request_headers || []) do |url, header|
         handle_error do
           uploader = blank_uploader
           uploader.download!(url, header || {})
           @uploaders << uploader
         end
       end
+      write_temporary_identifier
     end
 
     def store!
-      uploaders.reject(&:blank?).each(&:store!)
+      additions, remains = uploaders.partition(&:cached?)
+      existing_paths = (@removed_uploaders + remains).map(&:store_path)
+      additions.each do |uploader|
+        uploader.deduplicate(existing_paths)
+        uploader.store!
+        existing_paths << uploader.store_path
+      end
+      @added_uploaders += additions
+    end
+
+    def write_identifier
+      return if record.frozen?
+
+      clear! if remove?
+      record.write_uploader(serialization_column, identifier)
     end
 
     def urls(*args)
@@ -113,52 +164,50 @@ module CarrierWave
       uploaders.none?(&:present?)
     end
 
+    def remove=(value)
+      @remove = value
+      write_temporary_identifier
+    end
+
     def remove?
-      remove.present? && (remove == true || remove !~ /\A0|false$\z/)
+      remove.present? && (remove.to_s !~ /\A0|false$\z/)
     end
 
     def remove!
-      uploaders.reject(&:blank?).each(&:remove!)
-      @uploaders = []
+      uploaders.each(&:remove!)
+      clear!
     end
 
     def clear!
+      @removed_uploaders += uploaders
+      @remove = nil
       @uploaders = []
     end
 
+    def reset_changes!
+      @removed_uploaders = []
+      @added_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
+    def remove_previous
+      current_paths = uploaders.map(&:path)
+      @removed_uploaders
+        .reject {|uploader| current_paths.include?(uploader.path) }
+        .each { |uploader| uploader.remove! if uploader.remove_previously_stored_files_after_update }
+      reset_changes!
     end
 
-    attr_accessor :uploader_options
+    def remove_added
+      current_paths = (@removed_uploaders + uploaders.select(&:staged)).map(&:path)
+      @added_uploaders
+        .reject {|uploader| current_paths.include?(uploader.path) }
+        .each { |uploader| uploader.remove! }
+      reset_changes!
+    end
 
   private
 
@@ -169,7 +218,9 @@ module CarrierWave
 
     def clear_unstaged
       @uploaders ||= []
-      @uploaders.keep_if(&:staged)
+      staged, unstaged = @uploaders.partition(&:staged)
+      @uploaders = staged
+      @removed_uploaders += unstaged
     end
 
     def handle_error
@@ -184,5 +235,19 @@ module CarrierWave
       @integrity_errors << e
       raise e unless option(:ignore_integrity_errors)
     end
+
+    def write_temporary_identifier
+      return if record.frozen?
+
+      record.write_uploader(serialization_column, temporary_identifier)
+    end
+
+    def temporary_identifiers
+      if remove?
+        []
+      else
+        uploaders.map { |uploader| uploader.temporary_identifier }
+      end
+    end
   end # Mounter
 end # CarrierWave

data/lib/carrierwave/orm/activerecord.rb

@@ -6,40 +6,6 @@ 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)
-          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)
@@ -56,39 +22,18 @@ 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
       after_commit :"mark_remove_#{column}_false", :on => :update
+
+      after_commit :"reset_previous_changes_for_#{column}"
       after_commit :"remove_previously_stored_#{column}", :on => :update
-      after_commit :"store_#{column}!", :on => [:create, :update]
+      after_rollback :"remove_rolled_back_#{column}"
 
       mod = Module.new
       prepend mod
       mod.class_eval <<-RUBY, __FILE__, __LINE__+1
-        def #{column}=(new_file)
-          column = _mounter(:#{column}).serialization_column
-          if !(new_file.blank? && __send__(:#{column}).blank?)
-            __send__(:"\#{column}_will_change!")
-          end
-
-          super
-        end
-
-        def remove_#{column}=(value)
-          column = _mounter(:#{column}).serialization_column
-          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
-        end
-
         # Reset cached mounter on record reload
         def reload(*)
           @_mounters = nil
@@ -97,7 +42,16 @@ module CarrierWave
 
         # Reset cached mounter on record dup
         def initialize_dup(other)
-          @_mounters = nil
+          old_uploaders = _mounter(:"#{column}").uploaders
+          @_mounters[:"#{column}"] = nil
+          # The attribute needs to be cleared to prevent it from picked up as identifier
+          write_attribute(:"#{column}", nil)
+          super
+          _mounter(:"#{column}").cache(old_uploaders)
+        end
+
+        def write_#{column}_identifier
+          return unless has_attribute?(_mounter(:#{column}).serialization_column)
           super
         end
       RUBY

data/lib/carrierwave/processing/mini_magick.rb

@@ -88,7 +88,7 @@ module CarrierWave
     #
     # === Parameters
     #
-    # [format (#to_s)] an abreviation of the format
+    # [format (#to_s)] an abbreviation of the format
     #
     # === Yields
     #
@@ -264,7 +264,8 @@ module CarrierWave
 
       image.run_command("identify", current_path)
     rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
-      message = I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e)
+      raise e if e.message =~ /(You must have .+ installed|is not installed|executable not found)/
+      message = I18n.translate(:"errors.messages.processing_error")
       raise CarrierWave::ProcessingError, message
     ensure
       image.destroy! if image
@@ -306,26 +307,27 @@ module CarrierWave
 
       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.content_type = Marcel::Magic.by_path(move_to).try(:type)
         file.move_to(move_to, permissions, directory_permissions)
       end
     rescue ::MiniMagick::Error, ::MiniMagick::Invalid => e
-      message = I18n.translate(:"errors.messages.mini_magick_processing_error", :e => e)
+      raise e if e.message =~ /(You must have .+ installed|is not installed|executable not found)/
+      message = I18n.translate(:"errors.messages.processing_error")
       raise CarrierWave::ProcessingError, message
     end
 
-    private
+  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
+    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
+    def mini_magick_image
+      ::MiniMagick::Image.read(read)
+    end
 
   end # MiniMagick
 end # CarrierWave

data/lib/carrierwave/processing/rmagick.rb

@@ -62,10 +62,12 @@ module CarrierWave
       begin
         require "rmagick"
       rescue LoadError
-        require "RMagick"
-      rescue LoadError => e
-        e.message << " (You may need to install the rmagick gem)"
-        raise e
+        begin
+          require "RMagick"
+        rescue LoadError => e
+          e.message << " (You may need to install the rmagick gem)"
+          raise e
+        end
       end
 
       prepend Module.new {
@@ -109,7 +111,7 @@ module CarrierWave
     #
     # === Parameters
     #
-    # [format (#to_s)] an abreviation of the format
+    # [format (#to_s)] an abbreviation of the format
     #
     # === Yields
     #
@@ -228,13 +230,7 @@ module CarrierWave
       height = dimension_from height
       manipulate! do |img|
         img.resize_to_fit!(width, height)
-        new_img = ::Magick::Image.new(width, height) { |img| img.background_color = background == :transparent ? 'rgba(255,255,255,0)' : background.to_s }
-        if background == :transparent
-          filled = new_img.matte_floodfill(1, 1)
-        else
-          filled = new_img.color_floodfill(1, 1, ::Magick::Pixel.from_color(background))
-        end
-        destroy_image(new_img)
+        filled = ::Magick::Image.new(width, height) { |image| image.background_color = background == :transparent ? 'rgba(255,255,255,0)' : background.to_s }
         filled.composite!(img, gravity, ::Magick::OverCompositeOp)
         destroy_image(img)
         filled = yield(filled) if block_given?
@@ -363,15 +359,15 @@ module CarrierWave
       if options[:format] || @format
         frames.write("#{options[:format] || @format}:#{current_path}", &write_block)
         move_to = current_path.chomp(File.extname(current_path)) + ".#{options[:format] || @format}"
-        file.content_type = ::MiniMime.lookup_by_filename(move_to).content_type
+        file.content_type = Marcel::Magic.by_path(move_to).try(:type)
         file.move_to(move_to, permissions, directory_permissions)
       else
         frames.write(current_path, &write_block)
       end
 
       destroy_image(frames)
-    rescue ::Magick::ImageMagickError => e
-      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.rmagick_processing_error", :e => e)
+    rescue ::Magick::ImageMagickError
+      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.processing_error")
     end
 
   private

data/lib/carrierwave/processing/vips.rb

@@ -259,26 +259,26 @@ module CarrierWave
 
       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.content_type = Marcel::Magic.by_path(move_to).try(:type)
         file.move_to(move_to, permissions, directory_permissions)
       end
-    rescue ::Vips::Error => e
-      message = I18n.translate(:"errors.messages.vips_processing_error", :e => e)
+    rescue ::Vips::Error
+      message = I18n.translate(:"errors.messages.processing_error")
       raise CarrierWave::ProcessingError, message
     end
 
-    private
+  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
+    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
+    def vips_image
+      ::Vips::Image.new_from_buffer(read, "")
+    end
 
   end # Vips
 end # CarrierWave