carrierwave 1.3.1 → 3.0.5

data/lib/carrierwave/uploader/store.rb

@@ -11,7 +11,7 @@ module CarrierWave
         prepend Module.new {
           def initialize(*)
             super
-            @file, @filename, @cache_id = nil
+            @file, @filename, @cache_id, @identifier, @deduplication_index = nil
           end
         }
       end
@@ -34,9 +34,26 @@ module CarrierWave
         @filename
       end
 
+      ##
+      # Returns a filename which doesn't conflict with already-stored files.
+      #
+      # === Returns
+      #
+      # [String] the filename with suffix added for deduplication
+      #
+      def deduplicated_filename
+        return unless filename
+        return filename unless @deduplication_index
+
+        parts = filename.split('.')
+        basename = parts.shift
+        basename.sub!(/ ?\(\d+\)\z/, '')
+        ([basename.to_s + (@deduplication_index > 1 ? "(#{@deduplication_index})" : '')] + parts).join('.')
+      end
+
       ##
       # Calculates the path where the file should be stored. If +for_file+ is given, it will be
-      # used as the filename, otherwise +CarrierWave::Uploader#filename+ is assumed.
+      # used as the identifier, otherwise +CarrierWave::Uploader#identifier+ is assumed.
       #
       # === Parameters
       #
@@ -46,7 +63,7 @@ module CarrierWave
       #
       # [String] the store path
       #
-      def store_path(for_file=filename)
+      def store_path(for_file=identifier)
         File.join([store_dir, full_filename(for_file)].compact)
       end
 
@@ -60,8 +77,8 @@ module CarrierWave
       # [new_file (File, IOString, Tempfile)] any kind of file object
       #
       def store!(new_file=nil)
-        cache!(new_file) if new_file && ((@cache_id != parent_cache_id) || @cache_id.nil?)
-        if !cache_only and @file and @cache_id
+        cache!(new_file) if new_file && !cached?
+        if !cache_only && @file && @cache_id
           with_callbacks(:store, new_file) do
             new_file = storage.store!(@file)
             if delete_tmp_file_after_storage
@@ -69,7 +86,9 @@ module CarrierWave
               cache_storage.delete_dir!(cache_path(nil))
             end
             @file = new_file
-            @cache_id = nil
+            @identifier = storage.identifier
+            @original_filename = @cache_id = @deduplication_index = nil
+            @staged = false
           end
         end
       end
@@ -84,13 +103,34 @@ module CarrierWave
       def retrieve_from_store!(identifier)
         with_callbacks(:retrieve_from_store, identifier) do
           @file = storage.retrieve!(identifier)
+          @identifier = identifier
+        end
+      end
+
+      ##
+      # Look for an identifier which doesn't collide with the given already-stored identifiers.
+      # It is done by adding a index number as the suffix.
+      # For example, if there's 'image.jpg' and the @deduplication_index is set to 2,
+      # The stored file will be named as 'image(2).jpg'.
+      #
+      # === Parameters
+      #
+      # [current_identifiers (Array[String])] List of identifiers for already-stored files
+      #
+      def deduplicate(current_identifiers)
+        @deduplication_index = nil
+        return unless current_identifiers.include?(identifier)
+
+        (1..current_identifiers.size + 1).each do |i|
+          @deduplication_index = i
+          break unless current_identifiers.include?(identifier)
         end
       end
 
     private
 
       def full_filename(for_file)
-        for_file
+        forcing_extension(for_file)
       end
 
       def storage

data/lib/carrierwave/uploader/url.rb

@@ -15,12 +15,15 @@ module CarrierWave
       # [String] the location where this file is accessible via a url
       #
       def url(options = {})
-        if file.respond_to?(:url) and not (tmp_url = file.url).blank?
-          file.method(:url).arity == 0 ? tmp_url : file.url(options)
-        elsif file.respond_to?(:path)
+        if file.respond_to?(:url)
+          tmp_url = file.method(:url).arity.zero? ? file.url : file.url(options)
+          return tmp_url if tmp_url.present?
+        end
+
+        if file.respond_to?(:path)
           path = encode_path(file.path.sub(File.expand_path(root), ''))
 
-          if host = asset_host
+          if (host = asset_host)
             if host.respond_to? :call
               "#{host.call(file)}#{path}"
             else

data/lib/carrierwave/uploader/versions.rb

@@ -1,6 +1,89 @@
+require "active_support/core_ext/object/deep_dup"
+
 module CarrierWave
   module Uploader
     module Versions
+      class Builder
+        def initialize(name)
+          @name = name
+          @options = {}
+          @blocks = []
+          @klass = nil
+        end
+
+        def configure(options, &block)
+          @options.merge!(options)
+          @blocks << block if block
+          @klass = nil
+        end
+
+        def build(superclass)
+          return @klass if @klass
+          @klass = Class.new(superclass)
+          superclass.const_set("#{@name.to_s.camelize}VersionUploader", @klass)
+
+          @klass.version_names += [@name]
+          @klass.versions = {}
+          @klass.processors = []
+          @klass.version_options = @options
+          @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # Define the enable_processing method for versions so they get the
+            # value from the parent class unless explicitly overwritten
+            def self.enable_processing(value=nil)
+              self.enable_processing = value if value
+              if defined?(@enable_processing) && !@enable_processing.nil?
+                @enable_processing
+              else
+                superclass.enable_processing
+              end
+            end
+
+            # Regardless of what is set in the parent uploader, do not enforce the
+            # move_to_cache config option on versions because it moves the original
+            # file to the version's target file.
+            #
+            # If you want to enforce this setting on versions, override this method
+            # in each version:
+            #
+            # version :thumb do
+            #   def move_to_cache
+            #     true
+            #   end
+            # end
+            #
+            def move_to_cache
+              false
+            end
+
+            # Need to rely on the parent version's identifier, as versions don't have its own one.
+            def identifier
+              parent_version.identifier
+            end
+          RUBY
+          @blocks.each { |block| @klass.class_eval(&block) }
+          @klass
+        end
+
+        def deep_dup
+          other = dup
+          other.instance_variable_set(:@blocks, @blocks.dup)
+          other
+        end
+
+        def method_missing(name, *args)
+          super
+        rescue NoMethodError => e
+          raise e.exception <<~ERROR
+            #{e.message}
+            If you're trying to configure a version, do it inside a block like `version(:thumb) { self.#{name} #{args.map(&:inspect).join(', ')} }`.
+          ERROR
+        end
+
+        def respond_to_missing?(*)
+          super
+        end
+      end
+
       extend ActiveSupport::Concern
 
       include CarrierWave::Uploader::Callbacks
@@ -11,9 +94,8 @@ module CarrierWave
         self.versions = {}
         self.version_names = []
 
-        attr_accessor :parent_cache_id, :parent_version
+        attr_accessor :parent_version
 
-        after :cache, :assign_parent_cache_id
         after :cache, :cache_versions!
         after :store, :store_versions!
         after :remove, :remove_versions!
@@ -51,80 +133,33 @@ module CarrierWave
         #         process :scale => [200, 200]
         #       end
         #
+        #       version :square, :unless => :invalid_image_type? do
+        #         process :scale => [100, 100]
+        #       end
+        #
         #     end
         #
         def version(name, options = {}, &block)
           name = name.to_sym
-          build_version(name, options)
+          versions[name] ||= Builder.new(name)
+          versions[name].configure(options, &block)
 
-          versions[name].class_eval(&block) if block
-          versions[name]
-        end
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              versions[:#{name}]
+            end
+          RUBY
 
-        def recursively_apply_block_to_versions(&block)
-          versions.each do |name, version|
-            version.class_eval(&block)
-            version.recursively_apply_block_to_versions(&block)
-          end
+          versions[name]
         end
 
       private
 
-        def build_version(name, options)
-          if !versions.has_key?(name)
-            uploader = Class.new(self)
-            const_set("Uploader#{uploader.object_id}".tr('-', '_'), uploader)
-            uploader.version_names += [name]
-            uploader.versions = {}
-            uploader.processors = []
-            uploader.version_options = options
-
-            uploader.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              # Define the enable_processing method for versions so they get the
-              # value from the parent class unless explicitly overwritten
-              def self.enable_processing(value=nil)
-                self.enable_processing = value if value
-                if defined?(@enable_processing) && !@enable_processing.nil?
-                  @enable_processing
-                else
-                  superclass.enable_processing
-                end
-              end
-
-              # Regardless of what is set in the parent uploader, do not enforce the
-              # move_to_cache config option on versions because it moves the original
-              # file to the version's target file.
-              #
-              # If you want to enforce this setting on versions, override this method
-              # in each version:
-              #
-              # version :thumb do
-              #   def move_to_cache
-              #     true
-              #   end
-              # end
-              #
-              def move_to_cache
-                false
-              end
-            RUBY
-
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                versions[:#{name}]
-              end
-            RUBY
-          else
-            uploader = Class.new(versions[name])
-            const_set("Uploader#{uploader.object_id}".tr('-', '_'), uploader)
-            uploader.processors = []
-            uploader.version_options = uploader.version_options.merge(options)
-          end
-
-          # Add the current version hash to class attribute :versions
-          self.versions = versions.merge(name => uploader)
+        def inherited(subclass)
+          # To prevent subclass version changes affecting superclass versions
+          subclass.versions = versions.deep_dup
+          super
         end
-
       end # ClassMethods
 
       ##
@@ -138,7 +173,7 @@ module CarrierWave
         return @versions if @versions
         @versions = {}
         self.class.versions.each do |name, version|
-          @versions[name] = version.new(model, mounted_as)
+          @versions[name] = version.build(self.class).new(model, mounted_as)
           @versions[name].parent_version = self
         end
         @versions
@@ -161,25 +196,44 @@ module CarrierWave
       #
       # === Returns
       #
-      # [Boolean] True when the version exists according to its :if condition
+      # [Boolean] True when the version exists according to its :if or :unless condition
       #
       def version_exists?(name)
         name = name.to_sym
 
-        return false unless self.class.versions.has_key?(name)
+        return false unless versions.has_key?(name)
 
-        condition = self.class.versions[name].version_options[:if]
-        if(condition)
-          if(condition.respond_to?(:call))
-            condition.call(self, :version => name, :file => file)
+        if_condition = versions[name].class.version_options[:if]
+        unless_condition = versions[name].class.version_options[:unless]
+
+        if if_condition
+          if if_condition.respond_to?(:call)
+            if_condition.call(self, :version => name, :file => file)
+          else
+            send(if_condition, file)
+          end
+        elsif unless_condition
+          if unless_condition.respond_to?(:call)
+            !unless_condition.call(self, :version => name, :file => file)
           else
-            send(condition, file)
+            !send(unless_condition, file)
           end
         else
           true
         end
       end
 
+      ##
+      # Copies the parent's cache_id when caching a version file.
+      # This behavior is not essential but it makes easier to understand
+      # that the cached files are generated by the single upload attempt.
+      #
+      def cache!(*args)
+        self.cache_id = parent_version.cache_id if parent_version
+
+        super
+      end
+
       ##
       # When given a version name as a parameter, will return the url for that version
       # This also works with nested versions.
@@ -220,26 +274,26 @@ module CarrierWave
       # Recreate versions and reprocess them. This can be used to recreate
       # versions if their parameters somehow have changed.
       #
-      def recreate_versions!(*versions)
-        # Some files could possibly not be stored on the local disk. This
-        # doesn't play nicely with processing. Make sure that we're only
-        # processing a cached file
-        #
-        # The call to store! will trigger the necessary callbacks to both
-        # process this version and all sub-versions
-        if versions.any?
-          file = sanitized_file if !cached?
-          store_versions!(file, versions)
-        else
-          cache! if !cached?
-          store!
+      def recreate_versions!(*names)
+        # As well as specified versions, we need to reprocess versions
+        # that are the source of another version.
+
+        self.cache_id = CarrierWave.generate_cache_id
+        derived_versions.each do |name, v|
+          v.cache!(file) if names.empty? || !(v.descendant_version_names & names).empty?
+        end
+        active_versions.each do |name, v|
+          v.store! if names.empty? || names.include?(name)
         end
+      ensure
+        @cache_id = nil
       end
 
-    private
-      def assign_parent_cache_id(file)
-        active_versions.each do |name, uploader|
-          uploader.parent_cache_id = @cache_id
+    protected
+
+      def descendant_version_names
+        [version_name] + derived_versions.flat_map do |name, version|
+          version.descendant_version_names
         end
       end
 
@@ -249,16 +303,18 @@ module CarrierWave
         end
       end
 
-      def dependent_versions
+    private
+
+      def derived_versions
         active_versions.reject do |name, v|
           v.class.version_options[:from_version]
-        end.to_a + sibling_versions.select do |name, v|
+        end.to_a + active_sibling_versions.select do |name, v|
           v.class.version_options[:from_version] == self.class.version_names.last
         end.to_a
       end
 
-      def sibling_versions
-        parent_version.try(:versions) || []
+      def active_sibling_versions
+        parent_version&.active_versions || []
       end
 
       def full_filename(for_file)
@@ -270,19 +326,11 @@ module CarrierWave
       end
 
       def cache_versions!(new_file)
-        dependent_versions.each do |name, v|
-          v.send(:cache_id=, @cache_id)
-          v.cache!(new_file)
-        end
+        derived_versions.each { |name, v| v.cache!(new_file) }
       end
 
-      def store_versions!(new_file, versions=nil)
-        if versions
-          active = Hash[active_versions]
-          versions.each { |v| active[v].try(:store!, new_file) } unless active.empty?
-        else
-          active_versions.each { |name, v| v.store!(new_file) }
-        end
+      def store_versions!(new_file)
+        active_versions.each { |name, v| v.store!(new_file) }
       end
 
       def remove_versions!

data/lib/carrierwave/uploader.rb

@@ -7,11 +7,12 @@ require "carrierwave/uploader/cache"
 require "carrierwave/uploader/store"
 require "carrierwave/uploader/download"
 require "carrierwave/uploader/remove"
-require "carrierwave/uploader/extension_whitelist"
-require "carrierwave/uploader/extension_blacklist"
-require "carrierwave/uploader/content_type_whitelist"
-require "carrierwave/uploader/content_type_blacklist"
+require "carrierwave/uploader/extension_allowlist"
+require "carrierwave/uploader/extension_denylist"
+require "carrierwave/uploader/content_type_allowlist"
+require "carrierwave/uploader/content_type_denylist"
 require "carrierwave/uploader/file_size"
+require "carrierwave/uploader/dimension"
 require "carrierwave/uploader/processing"
 require "carrierwave/uploader/versions"
 require "carrierwave/uploader/default_url"
@@ -43,15 +44,6 @@ module CarrierWave
     class Base
       attr_reader :file
 
-      ##
-      # Workaround for class_attribute malfunction when used with Module#prepend
-      #
-      if RUBY_VERSION < '2.1.0'
-        def self.singleton_class?
-          !ancestors.include? self
-        end
-      end
-
       include CarrierWave::Uploader::Configuration
       include CarrierWave::Uploader::Callbacks
       include CarrierWave::Uploader::Proxy
@@ -61,11 +53,12 @@ module CarrierWave
       include CarrierWave::Uploader::Store
       include CarrierWave::Uploader::Download
       include CarrierWave::Uploader::Remove
-      include CarrierWave::Uploader::ExtensionWhitelist
-      include CarrierWave::Uploader::ExtensionBlacklist
-      include CarrierWave::Uploader::ContentTypeWhitelist
-      include CarrierWave::Uploader::ContentTypeBlacklist
+      include CarrierWave::Uploader::ExtensionAllowlist
+      include CarrierWave::Uploader::ExtensionDenylist
+      include CarrierWave::Uploader::ContentTypeAllowlist
+      include CarrierWave::Uploader::ContentTypeDenylist
       include CarrierWave::Uploader::FileSize
+      include CarrierWave::Uploader::Dimension
       include CarrierWave::Uploader::Processing
       include CarrierWave::Uploader::Versions
       include CarrierWave::Uploader::DefaultUrl

data/lib/carrierwave/utilities/file_name.rb

@@ -0,0 +1,47 @@
+module CarrierWave
+  module Utilities
+    module 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] extension of file or "" if the file has no extension
+      #
+      def extension
+        split_extension(filename)[1] if filename
+      end
+
+    private
+
+      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"
+        ]
+
+        extension_matchers.each do |regexp|
+          if filename =~ regexp
+            return $1, $2
+          end
+        end
+
+        [filename, ""] # In case we weren't able to split the extension
+      end
+    end # FileName
+  end # Utilities
+end # CarrierWave

data/lib/carrierwave/utilities/uri.rb

@@ -3,20 +3,23 @@ require 'uri'
 module CarrierWave
   module Utilities
     module Uri
-    # based on Ruby < 2.0's URI.encode
-    SAFE_STRING = URI::REGEXP::PATTERN::UNRESERVED + '\/'
-    UNSAFE = Regexp.new("[^#{SAFE_STRING}]", false)
+      # based on Ruby < 2.0's URI.encode
+      PATH_SAFE = URI::REGEXP::PATTERN::UNRESERVED + '\/'
+      PATH_UNSAFE = Regexp.new("[^#{PATH_SAFE}]", false)
+      NON_ASCII = /[^[:ascii:]]/.freeze
 
     private
+
       def encode_path(path)
-        path.to_s.gsub(UNSAFE) do
-          us = $&
-          tmp = ''
-          us.each_byte do |uc|
-            tmp << sprintf('%%%02X', uc)
-          end
-          tmp
-        end
+        URI::DEFAULT_PARSER.escape(path, PATH_UNSAFE)
+      end
+
+      def encode_non_ascii(str)
+        URI::DEFAULT_PARSER.escape(str, NON_ASCII)
+      end
+
+      def decode_uri(str)
+        URI::DEFAULT_PARSER.unescape(str)
       end
     end # Uri
   end # Utilities

data/lib/carrierwave/utilities.rb

@@ -1,4 +1,5 @@
 require 'carrierwave/utilities/uri'
+require 'carrierwave/utilities/file_name'
 
 module CarrierWave
   module Utilities

data/lib/carrierwave/validations/active_model.rb

@@ -11,9 +11,8 @@ module CarrierWave
       class ProcessingValidator < ::ActiveModel::EachValidator
 
         def validate_each(record, attribute, value)
-          if e = record.__send__("#{attribute}_processing_error")
-            message = (e.message == e.class.to_s) ? :carrierwave_processing_error : e.message
-            record.errors.add(attribute, message)
+          record.__send__("#{attribute}_processing_errors").each do |e|
+            record.errors.add(attribute, :carrierwave_processing_error, message: (e.message != e.class.to_s) && e.message)
           end
         end
       end
@@ -21,9 +20,8 @@ module CarrierWave
       class IntegrityValidator < ::ActiveModel::EachValidator
 
         def validate_each(record, attribute, value)
-          if e = record.__send__("#{attribute}_integrity_error")
-            message = (e.message == e.class.to_s) ? :carrierwave_integrity_error : e.message
-            record.errors.add(attribute, message)
+          record.__send__("#{attribute}_integrity_errors").each do |e|
+            record.errors.add(attribute, :carrierwave_integrity_error, message: (e.message != e.class.to_s) && e.message)
           end
         end
       end
@@ -31,9 +29,8 @@ module CarrierWave
       class DownloadValidator < ::ActiveModel::EachValidator
 
         def validate_each(record, attribute, value)
-          if e = record.__send__("#{attribute}_download_error")
-            message = (e.message == e.class.to_s) ? :carrierwave_download_error : e.message
-            record.errors.add(attribute, message)
+          record.__send__("#{attribute}_download_errors").each do |e|
+            record.errors.add(attribute, :carrierwave_download_error, message: (e.message != e.class.to_s) && e.message)
           end
         end
       end
@@ -58,6 +55,7 @@ module CarrierWave
         def validates_processing_of(*attr_names)
           validates_with ProcessingValidator, _merge_attributes(attr_names)
         end
+
         #
         ##
         # Makes the record invalid if the remote file couldn't be downloaded

data/lib/carrierwave/version.rb

@@ -1,3 +1,3 @@
 module CarrierWave
-  VERSION = "1.3.1"
+  VERSION = "3.0.5".freeze
 end