carrierwave 1.3.2 → 3.0.7

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_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
 
@@ -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.merge(active_sibling_versions.select do |name, v|
           v.class.version_options[:from_version] == self.class.version_names.last
-        end.to_a
+        end)
       end
 
-      def sibling_versions
-        parent_version.try(:versions) || []
+      def active_sibling_versions
+        parent_version&.active_versions || {}
       end
 
       def full_filename(for_file)
@@ -270,31 +326,23 @@ 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_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)
-        active_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)
-        active_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

@@ -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.2"
+  VERSION = "3.0.7".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
@@ -72,6 +63,10 @@ elsif defined?(Rails)
           require 'carrierwave/orm/activerecord'
         end
       end
+
+      config.before_eager_load do
+        CarrierWave::Storage::Fog.eager_load
+      end
     end
   end
 
@@ -80,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
 

data/lib/generators/templates/{uploader.rb → uploader.rb.erb}

@@ -33,15 +33,15 @@ class <%= class_name %>Uploader < CarrierWave::Uploader::Base
   #   process resize_to_fit: [50, 50]
   # end
 
-  # Add a white list of extensions which are allowed to be uploaded.
+  # Add an allowlist of extensions which are allowed to be uploaded.
   # For images you might use something like this:
-  # def extension_whitelist
+  # def extension_allowlist
   #   %w(jpg jpeg gif png)
   # end
 
   # Override the filename of the uploaded files:
   # Avoid using model.id or version_name here, see uploader/store.rb for details.
   # def filename
-  #   "something.jpg" if original_filename
+  #   "something.jpg"
   # end
 end

data/lib/generators/uploader_generator.rb

@@ -1,7 +1,7 @@
 class UploaderGenerator < Rails::Generators::NamedBase
-  source_root File.expand_path("../templates", __FILE__)
+  source_root File.expand_path('templates', __dir__)
 
   def create_uploader_file
-    template "uploader.rb", File.join('app/uploaders', class_path, "#{file_name}_uploader.rb")
+    template "uploader.rb.erb", File.join('app/uploaders', class_path, "#{file_name}_uploader.rb")
   end
-end
+end