carrierwave 2.2.0 → 3.0.0

data/lib/carrierwave/uploader/store.rb

@@ -11,7 +11,7 @@ module CarrierWave
         prepend Module.new {
           def initialize(*)
             super
-            @file, @filename, @cache_id, @identifier = nil
+            @file, @filename, @cache_id, @identifier, @deduplication_index = nil
           end
         }
       end
@@ -34,9 +34,25 @@ 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
+
+        parts = filename.split('.')
+        basename = parts.shift
+        basename.sub!(/ ?\(\d+\)\z/, '')
+        ([basename.to_s + (@deduplication_index ? "(#{@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 +62,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,7 +76,7 @@ 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?)
+        cache!(new_file) if new_file && !cached?
         if !cache_only && @file && @cache_id
           with_callbacks(:store, new_file) do
             new_file = storage.store!(@file)
@@ -69,7 +85,8 @@ module CarrierWave
               cache_storage.delete_dir!(cache_path(nil))
             end
             @file = new_file
-            @cache_id = @identifier = nil
+            @identifier = storage.identifier
+            @cache_id = @deduplication_index = nil
             @staged = false
           end
         end
@@ -89,10 +106,30 @@ module CarrierWave
         end
       end
 
+      ##
+      # Look for a store path which doesn't collide with the given already-stored paths.
+      # 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_paths (Array[String])] List of paths for already-stored files
+      #
+      def deduplicate(current_paths)
+        @deduplication_index = nil
+        return unless current_paths.include?(store_path)
+
+        (2..current_paths.size + 1).each do |i|
+          @deduplication_index = i
+          break unless current_paths.include?(store_path)
+        end
+      end
+
     private
 
       def full_filename(for_file)
-        for_file
+        forcing_extension(for_file)
       end
 
       def storage

data/lib/carrierwave/uploader/url.rb

@@ -23,7 +23,7 @@ module CarrierWave
         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,76 @@
 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
+            # 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 +81,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!
@@ -23,7 +92,7 @@ module CarrierWave
         prepend Module.new {
           def initialize(*)
             super
-            @versions, @versions_to_cache, @versions_to_store = nil
+            @versions = nil
           end
         }
       end
@@ -51,80 +120,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 +160,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 +183,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)
+
+        if_condition = versions[name].class.version_options[:if]
+        unless_condition = versions[name].class.version_options[:unless]
 
-        condition = self.class.versions[name].version_options[:if]
-        if(condition)
-          if(condition.respond_to?(:call))
-            condition.call(self, :version => name, :file => file)
+        if if_condition
+          if if_condition.respond_to?(:call)
+            if_condition.call(self, :version => name, :file => file)
           else
-            send(condition, file)
+            send(if_condition, file)
+          end
+        elsif unless_condition
+          if unless_condition.respond_to?(:call)
+            !unless_condition.call(self, :version => name, :file => file)
+          else
+            !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.
@@ -221,60 +262,25 @@ module CarrierWave
       # versions if their parameters somehow have changed.
       #
       def recreate_versions!(*names)
-        # 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
+        # As well as specified versions, we need to reprocess versions
+        # that are the source of another version.
 
-        if names.any?
-          set_versions_to_cache_and_store(names)
-          store!(file)
-          reset_versions_to_cache_and_store
-        else
-          cache! if !cached?
-          store!
+        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
-      end
-
-    private
-
-      def set_versions_to_cache_and_store(names)
-        @versions_to_cache = source_versions_of(names)
-        @versions_to_store = active_versions_with_names_in(@versions_to_cache + names)
-      end
-
-      def reset_versions_to_cache_and_store
-        @versions_to_cache, @versions_to_store = nil, nil
-      end
-
-      def versions_to_cache
-        @versions_to_cache || dependent_versions
-      end
-
-      def versions_to_store
-        @versions_to_store || active_versions
-      end
-
-      def source_versions_of(requested_names)
-        versions.inject([]) do |sources, (name, uploader)|
-          next sources unless requested_names.include?(name)
-          next sources unless source_name = uploader.class.version_options[:from_version]
-
-          sources << [source_name, versions[source_name]]
-        end.uniq
-      end
-
-      def active_versions_with_names_in(names)
-        active_versions.select do |pretendent_name, uploader|
-          names.include?(pretendent_name)
+        active_versions.each do |name, v|
+          v.store! if names.empty? || names.include?(name)
         end
+      ensure
+        @cache_id = nil
       end
 
-      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
 
@@ -284,16 +290,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)
@@ -305,14 +313,11 @@ module CarrierWave
       end
 
       def cache_versions!(new_file)
-        versions_to_cache.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_to_store.each { |name, v| v.store!(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"
@@ -52,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

@@ -12,8 +12,7 @@ module CarrierWave
 
         def validate_each(record, attribute, value)
           record.__send__("#{attribute}_processing_errors").each do |e|
-            message = (e.message == e.class.to_s) ? :carrierwave_processing_error : e.message
-            record.errors.add(attribute, message)
+            record.errors.add(attribute, :carrierwave_processing_error, message: (e.message != e.class.to_s) && e.message)
           end
         end
       end
@@ -22,8 +21,7 @@ module CarrierWave
 
         def validate_each(record, attribute, value)
           record.__send__("#{attribute}_integrity_errors").each do |e|
-            message = (e.message == e.class.to_s) ? :carrierwave_integrity_error : e.message
-            record.errors.add(attribute, message)
+            record.errors.add(attribute, :carrierwave_integrity_error, message: (e.message != e.class.to_s) && e.message)
           end
         end
       end
@@ -32,8 +30,7 @@ module CarrierWave
 
         def validate_each(record, attribute, value)
           record.__send__("#{attribute}_download_errors").each do |e|
-            message = (e.message == e.class.to_s) ? :carrierwave_download_error : e.message
-            record.errors.add(attribute, message)
+            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 = "2.2.0"
+  VERSION = "3.0.0".freeze
 end

data/lib/carrierwave.rb

@@ -25,16 +25,7 @@ module CarrierWave
 
 end
 
-if defined?(Merb)
-
-  CarrierWave.root = Merb.dir_for(:public)
-  Merb::BootLoader.before_app_loads do
-    # Setup path for uploaders and load all of them before classes are loaded
-    Merb.push_path(:uploaders, Merb.root / 'app' / 'uploaders', '*.rb')
-    Dir.glob(File.join(Merb.load_paths[:uploaders])).each {|f| require f }
-  end
-
-elsif defined?(Jets)
+if defined?(Jets)
 
   module CarrierWave
     class Turbine < Jets::Turbine
@@ -84,13 +75,14 @@ elsif defined?(Sinatra)
     CarrierWave.root = File.join(PADRINO_ROOT, "public")
   else
 
-    CarrierWave.root = if Sinatra::Application.respond_to?(:public_folder)
-      # Sinatra >= 1.3
-      Sinatra::Application.public_folder
-    else
-      # Sinatra < 1.3
-      Sinatra::Application.public
-    end
+    CarrierWave.root =
+      if Sinatra::Application.respond_to?(:public_folder)
+        # Sinatra >= 1.3
+        Sinatra::Application.public_folder
+      else
+        # Sinatra < 1.3
+        Sinatra::Application.public
+      end
   end
 end