carrierwave 2.2.2 → 3.1.0

data/lib/carrierwave/mount.rb

@@ -132,7 +132,7 @@ module CarrierWave
     #     end
     #
     def mount_uploader(column, uploader=nil, options={}, &block)
-      mount_base(column, uploader, options, &block)
+      mount_base(column, uploader, options.merge(multiple: false), &block)
 
       mod = Module.new
       include mod
@@ -163,21 +163,13 @@ module CarrierWave
         end
 
         def remote_#{column}_url=(url)
-          _mounter(:#{column}).remote_urls = [url]
+          _mounter(:#{column}).remote_urls = url
         end
 
         def remote_#{column}_request_header=(header)
           _mounter(:#{column}).remote_request_headers = [header]
         end
 
-        def write_#{column}_identifier
-          return if frozen?
-          mounter = _mounter(:#{column})
-
-          mounter.clear! if mounter.remove?
-          write_uploader(mounter.serialization_column, mounter.identifiers.first)
-        end
-
         def #{column}_identifier
           _mounter(:#{column}).read_identifiers[0]
         end
@@ -193,16 +185,6 @@ module CarrierWave
         def #{column}_download_error
           #{column}_download_errors.last
         end
-
-        def store_previous_changes_for_#{column}
-          attribute_changes = ::ActiveRecord.version.to_s.to_f >= 5.1 ? saved_changes : changes
-          @_previous_changes_for_#{column} = attribute_changes[_mounter(:#{column}).serialization_column]
-        end
-
-        def remove_previously_stored_#{column}
-          before, after = @_previous_changes_for_#{column}
-          _mounter(:#{column}).remove_previous([before], [after])
-        end
       RUBY
     end
 
@@ -295,7 +277,7 @@ module CarrierWave
     #     end
     #
     def mount_uploaders(column, uploader=nil, options={}, &block)
-      mount_base(column, uploader, options, &block)
+      mount_base(column, uploader, options.merge(multiple: true), &block)
 
       mod = Module.new
       include mod
@@ -334,35 +316,18 @@ module CarrierWave
           _mounter(:#{column}).remote_request_headers = headers
         end
 
-        def write_#{column}_identifier
-          return if frozen?
-          mounter = _mounter(:#{column})
-
-          mounter.clear! if mounter.remove?
-          write_uploader(mounter.serialization_column, mounter.identifiers.presence)
-        end
-
         def #{column}_identifiers
           _mounter(:#{column}).read_identifiers
         end
-
-        def store_previous_changes_for_#{column}
-          attribute_changes = ::ActiveRecord.version.to_s.to_f >= 5.1 ? saved_changes : changes
-          @_previous_changes_for_#{column} = attribute_changes[_mounter(:#{column}).serialization_column]
-        end
-
-        def remove_previously_stored_#{column}
-          _mounter(:#{column}).remove_previous(*@_previous_changes_for_#{column})
-        end
       RUBY
     end
 
-    private
+  private
 
     def mount_base(column, uploader=nil, options={}, &block)
       include CarrierWave::Mount::Extension
 
-      uploader = build_uploader(uploader, &block)
+      uploader = build_uploader(uploader, column, &block)
       uploaders[column.to_sym] = uploader
       uploader_options[column.to_sym] = options
 
@@ -387,6 +352,8 @@ module CarrierWave
 
         def remove_#{column}!
           _mounter(:#{column}).remove!
+          self.remove_#{column} = true
+          write_#{column}_identifier
         end
 
         def remove_#{column}=(value)
@@ -413,22 +380,36 @@ module CarrierWave
           _mounter(:#{column}).download_errors
         end
 
+        def write_#{column}_identifier
+          _mounter(:#{column}).write_identifier
+        end
+
         def mark_remove_#{column}_false
           _mounter(:#{column}).remove = false
         end
+
+        def reset_previous_changes_for_#{column}
+          _mounter(:#{column}).reset_changes!
+        end
+
+        def remove_previously_stored_#{column}
+          _mounter(:#{column}).remove_previous
+        end
+
+        def remove_rolled_back_#{column}
+          _mounter(:#{column}).remove_added
+        end
       RUBY
     end
 
-    def build_uploader(uploader, &block)
-      return uploader if uploader && !block_given?
+    def build_uploader(uploader, column, &block)
+      uploader ||= CarrierWave::Uploader::Base
+      return uploader unless block_given?
 
-      uploader = Class.new(uploader || CarrierWave::Uploader::Base)
-      const_set("Uploader#{uploader.object_id}".tr('-', '_'), uploader)
+      uploader = Class.new(uploader)
+      const_set("CarrierWave#{column.to_s.camelize}Uploader", uploader)
 
-      if block_given?
-        uploader.class_eval(&block)
-        uploader.recursively_apply_block_to_versions(&block)
-      end
+      uploader.class_eval(&block)
 
       uploader
     end
@@ -447,11 +428,16 @@ module CarrierWave
 
     private
 
+      def initialize_dup(other)
+        @_mounters = @_mounters.dup
+        super
+      end
+
       def _mounter(column)
         # We cannot memoize in frozen objects :(
-        return Mounter.new(self, column) if frozen?
+        return Mounter.build(self, column) if frozen?
         @_mounters ||= {}
-        @_mounters[column] ||= Mounter.new(self, column)
+        @_mounters[column] ||= Mounter.build(self, column)
       end
 
     end # Extension

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
 
-    def initialize(record, column, options={})
+    attr_reader :column, :record, :remote_urls, :remove,
+                :integrity_errors, :processing_errors, :download_errors
+    attr_accessor :remote_request_headers, :uploader_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,54 @@ 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
+      @download_errors.clear
       @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!)
+      uploaders.each(&:store!)
+    end
+
+    def write_identifier
+      return if record.frozen?
+
+      clear! if remove?
+
+      additions, remains = uploaders.partition(&:cached?)
+      existing_identifiers = (@removed_uploaders + remains).map(&:identifier)
+      additions.each do |uploader|
+        uploader.deduplicate(existing_identifiers)
+        existing_identifiers << uploader.identifier
+      end
+      @added_uploaders += additions
+
+      record.write_uploader(serialization_column, identifier)
     end
 
     def urls(*args)
@@ -113,52 +167,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 +221,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 +238,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,23 @@ 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}"
+      if ::ActiveRecord.try(:run_after_transaction_callbacks_in_order_defined)
+        after_commit :"remove_previously_stored_#{column}", :on => :update
+        after_commit :"reset_previous_changes_for_#{column}"
+        after_commit :"mark_remove_#{column}_false", :on => :update
+      else
+        after_commit :"mark_remove_#{column}_false", :on => :update
+        after_commit :"reset_previous_changes_for_#{column}"
+        after_commit :"remove_previously_stored_#{column}", :on => :update
+      end
       after_commit :"remove_#{column}!", :on => :destroy
-      after_commit :"mark_remove_#{column}_false", :on => :update
-      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 +47,16 @@ module CarrierWave
 
         # Reset cached mounter on record dup
         def initialize_dup(other)
-          @_mounters = nil
+          old_uploaders = _mounter(:"#{column}").uploaders
+          super
+          @_mounters[:"#{column}"] = nil
+          # The attribute needs to be cleared to prevent it from picked up as identifier
+          write_attribute(_mounter(:#{column}).serialization_column, nil)
+          _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

@@ -79,6 +79,10 @@ module CarrierWave
       def resize_and_pad(width, height, background=:transparent, gravity='Center')
         process :resize_and_pad => [width, height, background, gravity]
       end
+
+      def crop(left, top, width, height)
+        process :crop => [left, top, width, height]
+      end
     end
 
     ##
@@ -88,7 +92,7 @@ module CarrierWave
     #
     # === Parameters
     #
-    # [format (#to_s)] an abreviation of the format
+    # [format (#to_s)] an abbreviation of the format
     #
     # === Yields
     #
@@ -210,6 +214,31 @@ module CarrierWave
       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
+    #
+    # [MiniMagick::Image] additional manipulations to perform
+    #
+    def crop(left, top, width, height, combine_options: {}, &block)
+      width, height = resolve_dimensions(width, height)
+
+      minimagick!(block) do |builder|
+        builder.crop(left, top, width, height)
+          .apply(combine_options)
+      end
+    end
+
     ##
     # Returns the width of the image in pixels.
     #
@@ -262,9 +291,10 @@ module CarrierWave
       image = yield(image)
       FileUtils.mv image.path, current_path
 
-      image.run_command("identify", current_path)
+      ::MiniMagick::Image.new(current_path).identify
     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 +336,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