carrierwave 1.3.4 → 3.1.4

data/lib/carrierwave/mounter.rb

@@ -2,15 +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_error,
-      :processing_error, :download_error
-    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
@@ -32,27 +66,38 @@ 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
 
     def cache(new_files)
-      return if not new_files or new_files == ""
+      return if !new_files.is_a?(Array) && new_files.blank?
+      old_uploaders = uploaders
       @uploaders = new_files.map do |new_file|
-        uploader = blank_uploader
-        uploader.cache!(new_file)
-        uploader
-      end
-
-      @integrity_error = nil
-      @processing_error = nil
-    rescue CarrierWave::IntegrityError => e
-      @integrity_error = e
-      raise e unless option(:ignore_integrity_errors)
-    rescue CarrierWave::ProcessingError => e
-      @processing_error = e
-      raise e unless option(:ignore_processing_errors)
+        handle_error do
+          if new_file.is_a?(String)
+            if (uploader = old_uploaders.detect { |old_uploader| old_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.reject(&:blank?)
+      @removed_uploaders += (old_uploaders - @uploaders)
+      write_temporary_identifier
     end
 
     def cache_names
@@ -60,45 +105,58 @@ module CarrierWave
     end
 
     def cache_names=(cache_names)
-      return if not cache_names or cache_names == "" or uploaders.any?(&:cached?)
-      @uploaders = cache_names.map do |cache_name|
+      cache_names = cache_names.reject(&:blank?)
+      return if cache_names.blank?
+      clear_unstaged
+      cache_names.each do |cache_name|
         uploader = blank_uploader
         uploader.retrieve_from_cache!(cache_name)
-        uploader
+        @uploaders << uploader
+      rescue CarrierWave::InvalidParameter
+        # ignore
       end
-    rescue CarrierWave::InvalidParameter
+      write_temporary_identifier
     end
 
     def remote_urls=(urls)
-      return if not urls or urls == "" or 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
-      @download_error = nil
-      @integrity_error = nil
 
-      @uploaders = urls.zip(remote_request_headers || []).map do |url, header|
-        uploader = blank_uploader
-        uploader.download!(url, header || {})
-        uploader
+      clear_unstaged
+      @remote_urls.zip(remote_request_headers || []) do |url, header|
+        handle_error do
+          uploader = blank_uploader
+          uploader.download!(url, header || {})
+          @uploaders << uploader
+        end
       end
-
-    rescue CarrierWave::DownloadError => e
-      @download_error = e
-      raise e unless option(:ignore_download_errors)
-    rescue CarrierWave::ProcessingError => e
-      @processing_error = e
-      raise e unless option(:ignore_processing_errors)
-    rescue CarrierWave::IntegrityError => e
-      @integrity_error = e
-      raise e unless option(:ignore_integrity_errors)
+      write_temporary_identifier
     end
 
     def store!
-      if remove?
-        remove!
-      else
-        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)
@@ -109,50 +167,51 @@ module CarrierWave
       uploaders.none?(&:present?)
     end
 
+    def remove=(value)
+      uploaders # Ensure that uploaders are initialized based on the current 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.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|
-        if uploader.remove_previously_stored_files_after_update and not after_paths.include?(uploader.path)
-          uploader.remove!
-        end
-      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
 
@@ -161,5 +220,38 @@ module CarrierWave
       self.uploader_options[name] ||= record.class.uploader_option(column, name)
     end
 
+    def clear_unstaged
+      uploaders # Ensure that uploaders are initialized based on the current value
+      staged, unstaged = @uploaders.partition(&:staged)
+      @uploaders = staged
+      @removed_uploaders += unstaged
+    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
+
+    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,36 +6,6 @@ module CarrierWave
 
     include CarrierWave::Mount
 
-    ##
-    # See +CarrierWave::Mount#mount_uploader+ for documentation
-    #
-    def mount_uploader(column, uploader=nil, options={}, &block)
-      super
-
-      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
-
-      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)
@@ -54,35 +24,21 @@ module CarrierWave
 
       after_save :"store_#{column}!"
       before_save :"write_#{column}_identifier"
+      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_save :"store_previous_changes_for_#{column}"
-      after_commit :"remove_previously_stored_#{column}", :on => :update
-
-      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
-          __send__(:"\#{column}_will_change!")
-          super
-        end
-
-        def remove_#{column}!
-          self.remove_#{column} = true
-          write_#{column}_identifier
-          self.remove_#{column} = false
-          super
-        end
+      after_rollback :"remove_rolled_back_#{column}"
 
+      mod = Module.new
+      prepend mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
         # Reset cached mounter on record reload
         def reload(*)
           @_mounters = nil
@@ -91,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_uploader(_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