carrierwave 0.11.2 → 3.1.2

data/lib/carrierwave/uploader/versions.rb

@@ -1,26 +1,113 @@
-# encoding: utf-8
+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("VersionUploader#{@name.to_s.camelize}", @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
 
       included do
-        class_attribute :versions, :version_names, :instance_reader => false, :instance_writer => false
+        class_attribute :versions, :version_names, :version_options, :instance_reader => false, :instance_writer => false
 
         self.versions = {}
         self.version_names = []
 
-        attr_accessor :parent_cache_id
+        attr_accessor :parent_version
 
-        after :cache, :assign_parent_cache_id
         after :cache, :cache_versions!
         after :store, :store_versions!
         after :remove, :remove_versions!
         after :retrieve_from_cache, :retrieve_versions_from_cache!
         after :retrieve_from_store, :retrieve_versions_from_store!
+
+        prepend Module.new {
+          def initialize(*)
+            super
+            @versions = nil
+          end
+        }
       end
 
       module ClassMethods
@@ -46,78 +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) unless versions[name]
-
-          versions[name][:uploader].class_eval(&block) if block
-          versions[name]
-        end
-
-        def recursively_apply_block_to_versions(&block)
-          versions.each do |name, version|
-            version[:uploader].class_eval(&block)
-            version[:uploader].recursively_apply_block_to_versions(&block)
-          end
-        end
-
-      private
-
-        def build_version(name, options)
-          uploader = Class.new(self)
-          const_set("Uploader#{uploader.object_id}".gsub('-', '_'), uploader)
-          uploader.version_names += [name]
-          uploader.versions = {}
-          uploader.processors = []
-
-          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 !@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
+          versions[name] ||= Builder.new(name)
+          versions[name].configure(options, &block)
 
-          class_eval <<-RUBY
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}
               versions[:#{name}]
             end
           RUBY
 
-          # Add the current version hash to class attribute :versions
-          current_version = {
-            name => {
-              :uploader => uploader,
-              :options  => options
-            }
-          }
-          self.versions = versions.merge(current_version)
+          versions[name]
         end
 
+      private
+
+        def inherited(subclass)
+          # To prevent subclass version changes affecting superclass versions
+          subclass.versions = versions.deep_dup
+          super
+        end
       end # ClassMethods
 
       ##
@@ -131,7 +173,8 @@ module CarrierWave
         return @versions if @versions
         @versions = {}
         self.class.versions.each do |name, version|
-          @versions[name] = version[:uploader].new(model, mounted_as)
+          @versions[name] = version.build(self.class).new(model, mounted_as)
+          @versions[name].parent_version = self
         end
         @versions
       end
@@ -153,24 +196,45 @@ module CarrierWave
       #
       # === Returns
       #
-      # [Boolean] True when the version exists according to its :if condition
+      # [Boolean] True when the version satisfy its :if or :unless condition
       #
-      def version_exists?(name)
+      def version_active?(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][: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(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
+      alias_method :version_exists?, :version_active?
+      CarrierWave.deprecator.deprecate_methods(self, version_exists?: :version_active?)
+
+      ##
+      # 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
@@ -212,35 +276,49 @@ 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_value do |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
 
       def active_versions
         versions.select do |name, uploader|
-          version_exists?(name)
+          version_active?(name)
         end
       end
 
+    private
+
+      def derived_versions
+        active_versions.reject do |name, v|
+          v.class.version_options[:from_version]
+        end.merge(active_sibling_versions.select do |name, v|
+          v.class.version_options[:from_version] == self.class.version_names.last
+        end)
+      end
+
+      def active_sibling_versions
+        parent_version&.active_versions || {}
+      end
+
       def full_filename(for_file)
         [version_name, super(for_file)].compact.join('_')
       end
@@ -250,51 +328,23 @@ module CarrierWave
       end
 
       def cache_versions!(new_file)
-        # We might have processed the new_file argument after the callbacks were
-        # initialized, so get the actual file based off of the current state of
-        # our file
-        processed_parent = SanitizedFile.new :tempfile => self.file,
-          :filename => new_file.original_filename
-
-        active_versions.each do |name, v|
-          next if v.cached?
-
-          v.send(:cache_id=, cache_id)
-          # If option :from_version is present, create cache using cached file from
-          # version indicated
-          if self.class.versions[name][:options] && self.class.versions[name][:options][:from_version]
-            # Maybe the reference version has not been cached yet
-            unless versions[self.class.versions[name][:options][:from_version]].cached?
-              versions[self.class.versions[name][:options][:from_version]].cache!(processed_parent)
-            end
-            processed_version = SanitizedFile.new :tempfile => versions[self.class.versions[name][:options][:from_version]],
-              :filename => new_file.original_filename
-            v.cache!(processed_version)
-          else
-            v.cache!(processed_parent)
-          end
-        end
+        derived_versions.each_value { |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_value { |v| v.store!(new_file) }
       end
 
       def remove_versions!
-        versions.each { |name, v| v.remove! }
+        versions.each_value { |v| v.remove! }
       end
 
       def retrieve_versions_from_cache!(cache_name)
-        versions.each { |name, v| v.retrieve_from_cache!(cache_name) }
+        active_versions.each_value { |v| v.retrieve_from_cache!(cache_name) }
       end
 
       def retrieve_versions_from_store!(identifier)
-        versions.each { |name, v| v.retrieve_from_store!(identifier) }
+        active_versions.each_value { |v| v.retrieve_from_store!(identifier) }
       end
 
     end # Versions

data/lib/carrierwave/uploader.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require "carrierwave/uploader/configuration"
 require "carrierwave/uploader/callbacks"
 require "carrierwave/uploader/proxy"
@@ -9,10 +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"
@@ -53,10 +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

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

data/lib/carrierwave/utilities.rb

@@ -1,7 +1,5 @@
-# encoding: utf-8
-
 require 'carrierwave/utilities/uri'
-require 'carrierwave/utilities/deprecation'
+require 'carrierwave/utilities/file_name'
 
 module CarrierWave
   module Utilities

data/lib/carrierwave/validations/active_model.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'active_model/validator'
 require 'active_support/concern'
 
@@ -13,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
@@ -23,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
@@ -33,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
@@ -60,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 = "0.11.2"
+  VERSION = "3.1.2".freeze
 end