carrierwave 0.9.0 → 2.1.1

data/lib/carrierwave/uploader/cache.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+require 'securerandom'
 
 module CarrierWave
 
@@ -8,15 +8,27 @@ module CarrierWave
     end
   end
 
+  class CacheCounter
+    @@counter = 0
+
+    def self.increment
+      @@counter += 1
+    end
+  end
+
   ##
   # Generates a unique cache id for use in the caching system
   #
   # === Returns
   #
-  # [String] a cache id in the format TIMEINT-PID-RND
+  # [String] a cache id in the format TIMEINT-PID-COUNTER-RND
   #
   def self.generate_cache_id
-    Time.now.utc.to_i.to_s + '-' + Process.pid.to_s + '-' + ("%04d" % rand(9999))
+    [Time.now.utc.to_i,
+      SecureRandom.random_number(1_000_000_000_000_000),
+      '%04d' % (CarrierWave::CacheCounter.increment % 10_000),
+      '%04d' % SecureRandom.random_number(10_000)
+    ].map(&:to_s).join('-')
   end
 
   module Uploader
@@ -26,6 +38,16 @@ module CarrierWave
       include CarrierWave::Uploader::Callbacks
       include CarrierWave::Uploader::Configuration
 
+      included do
+        prepend Module.new {
+          def initialize(*)
+            super
+            @staged = false
+          end
+        }
+        attr_accessor :staged
+      end
+
       module ClassMethods
 
         ##
@@ -42,13 +64,7 @@ module CarrierWave
         # It's recommended that you keep cache files in one place only.
         #
         def clean_cached_files!(seconds=60*60*24)
-          Dir.glob(File.expand_path(File.join(cache_dir, '*'), CarrierWave.root)).each do |dir|
-            time = dir.scan(/(\d+)-\d+-\d+/).first.map { |t| t.to_i }
-            time = Time.at(*time)
-            if time < (Time.now.utc - seconds)
-              FileUtils.rm_rf(dir)
-            end
-          end
+          (cache_storage || storage).new(CarrierWave::Uploader::Base.new).clean_cache!(seconds)
         end
       end
 
@@ -74,16 +90,8 @@ module CarrierWave
       end
 
       def sanitized_file
-        _content = file.read
-        if _content.is_a?(File) # could be if storage is Fog
-          sanitized = CarrierWave::Storage::Fog.new(self).retrieve!(File.basename(_content.path))
-          sanitized.read if sanitized.exists?
-
-        else
-          sanitized = SanitizedFile.new :tempfile => StringIO.new(file.read),
-            :filename => File.basename(path), :content_type => file.content_type
-        end
-        sanitized
+        ActiveSupport::Deprecation.warn('#sanitized_file is deprecated, use #file instead.')
+        file
       end
 
       ##
@@ -91,10 +99,10 @@ module CarrierWave
       #
       # === Returns
       #
-      # [String] a cache name, in the format YYYYMMDD-HHMM-PID-RND/filename.txt
+      # [String] a cache name, in the format TIMEINT-PID-COUNTER-RND/filename.txt
       #
       def cache_name
-        File.join(cache_id, full_original_filename) if cache_id and original_filename
+        File.join(cache_id, full_original_filename) if cache_id && original_filename
       end
 
       ##
@@ -113,24 +121,31 @@ module CarrierWave
       #
       # [CarrierWave::FormNotMultipart] if the assigned parameter is a string
       #
-      def cache!(new_file = sanitized_file)
+      def cache!(new_file = file)
         new_file = CarrierWave::SanitizedFile.new(new_file)
+        return if new_file.empty?
 
-        unless new_file.empty?
-          raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
+        raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
 
-          with_callbacks(:cache, new_file) do
-            self.cache_id = CarrierWave.generate_cache_id unless cache_id
+        self.cache_id = CarrierWave.generate_cache_id unless cache_id
 
-            @filename = new_file.filename
-            self.original_filename = new_file.filename
+        @staged = true
+        @filename = new_file.filename
+        self.original_filename = new_file.filename
+
+        begin
+          # first, create a workfile on which we perform processings
+          if move_to_cache
+            @file = new_file.move_to(File.expand_path(workfile_path, root), permissions, directory_permissions)
+          else
+            @file = new_file.copy_to(File.expand_path(workfile_path, root), permissions, directory_permissions)
+          end
 
-            if move_to_cache
-              @file = new_file.move_to(cache_path, permissions, directory_permissions)
-            else
-              @file = new_file.copy_to(cache_path, permissions, directory_permissions)
-            end
+          with_callbacks(:cache, @file) do
+            @file = cache_storage.cache!(@file)
           end
+        ensure
+          FileUtils.rm_rf(workfile_path(''))
         end
       end
 
@@ -148,15 +163,31 @@ module CarrierWave
       def retrieve_from_cache!(cache_name)
         with_callbacks(:retrieve_from_cache, cache_name) do
           self.cache_id, self.original_filename = cache_name.to_s.split('/', 2)
+          @staged = true
           @filename = original_filename
-          @file = CarrierWave::SanitizedFile.new(cache_path)
+          @file = cache_storage.retrieve_from_cache!(full_filename(original_filename))
         end
       end
 
+      ##
+      # Calculates the path where the cache file should be stored.
+      #
+      # === Parameters
+      #
+      # [for_file (String)] name of the file <optional>
+      #
+      # === Returns
+      #
+      # [String] the cache path
+      #
+      def cache_path(for_file=full_filename(original_filename))
+        File.join(*[cache_dir, @cache_id, for_file].compact)
+      end
+
     private
 
-      def cache_path
-        File.expand_path(File.join(cache_dir, cache_name), root)
+      def workfile_path(for_file=original_filename)
+        File.join(CarrierWave.tmp_path, @cache_id, version_name.to_s, for_file)
       end
 
       attr_reader :cache_id, :original_filename
@@ -165,7 +196,9 @@ module CarrierWave
       alias_method :full_original_filename, :original_filename
 
       def cache_id=(cache_id)
-        raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A[\d]+\-[\d]+\-[\d]{4}\z/
+        # Earlier version used 3 part cache_id. Thus we should allow for
+        # the cache_id to have both 3 part and 4 part formats.
+        raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A(-)?[\d]+\-[\d]+(\-[\d]{4})?\-[\d]{4}\z/
         @cache_id = cache_id
       end
 
@@ -174,6 +207,9 @@ module CarrierWave
         @original_filename = filename
       end
 
+      def cache_storage
+        @cache_storage ||= (self.class.cache_storage || self.class.storage).new(self)
+      end
     end # Cache
   end # Uploader
 end # CarrierWave

data/lib/carrierwave/uploader/callbacks.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module Callbacks

data/lib/carrierwave/uploader/configuration.rb

@@ -1,3 +1,5 @@
+require 'carrierwave/downloader/base'
+
 module CarrierWave
 
   module Uploader
@@ -5,7 +7,7 @@ module CarrierWave
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :_storage, :instance_writer => false
+        class_attribute :_storage, :_cache_storage, :instance_writer => false
 
         add_config :root
         add_config :base_path
@@ -21,14 +23,17 @@ module CarrierWave
         add_config :move_to_cache
         add_config :move_to_store
         add_config :remove_previously_stored_files_after_update
+        add_config :downloader
 
         # fog
+        add_deprecated_config :fog_provider
         add_config :fog_attributes
         add_config :fog_credentials
         add_config :fog_directory
         add_config :fog_public
         add_config :fog_authenticated_url_expiration
         add_config :fog_use_ssl_for_aws
+        add_config :fog_aws_accelerate
 
         # Mounting
         add_config :ignore_integrity_errors
@@ -38,6 +43,7 @@ module CarrierWave
         add_config :validate_processing
         add_config :validate_download
         add_config :mount_on
+        add_config :cache_only
 
         # set default values
         reset_config
@@ -69,20 +75,58 @@ module CarrierWave
         #     storage MyCustomStorageEngine
         #
         def storage(storage = nil)
-          if storage
-            self._storage = storage.is_a?(Symbol) ? eval(storage_engines[storage]) : storage
+          case storage
+          when Symbol
+            if storage_engine = storage_engines[storage]
+              self._storage = eval storage_engine
+            else
+              raise CarrierWave::UnknownStorageError, "Unknown storage: #{storage}"
+            end
+          when nil
+            storage
+          else
+            self._storage = storage
           end
           _storage
         end
         alias_method :storage=, :storage
 
+        ##
+        # Sets the cache storage engine to be used when storing cache files with this uploader.
+        # Same as .storage except for required methods being #cache!(CarrierWave::SanitizedFile),
+        # #retrieve_from_cache! and #delete_dir!.
+        #
+        # === Parameters
+        #
+        # [storage (Symbol, Class)] The cache storage engine to use for this uploader
+        #
+        # === Returns
+        #
+        # [Class] the cache storage engine to be used with this uploader
+        #
+        # === Examples
+        #
+        #     cache_storage :file
+        #     cache_storage CarrierWave::Storage::File
+        #     cache_storage MyCustomStorageEngine
+        #
+        def cache_storage(storage = false)
+          unless storage == false
+            self._cache_storage = storage.is_a?(Symbol) ? eval(storage_engines[storage]) : storage
+          end
+          _cache_storage
+        end
+        alias_method :cache_storage=, :cache_storage
+
         def add_config(name)
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            @#{name} = nil
+
             def self.#{name}(value=nil)
               @#{name} = value if value
               return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
               name = superclass.#{name}
-              return nil if name.nil? && !instance_variable_defined?("@#{name}")
+              return nil if name.nil? && !instance_variable_defined?(:@#{name})
               @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
             end
 
@@ -99,13 +143,33 @@ module CarrierWave
               value = self.class.#{name} unless instance_variable_defined?(:@#{name})
               if value.instance_of?(Proc)
                 value.arity >= 1 ? value.call(self) : value.call
-              else 
+              else
                 value
               end
             end
           RUBY
         end
 
+        def add_deprecated_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(value=nil)
+              ActiveSupport::Deprecation.warn "##{name} is deprecated and has no effect"
+            end
+
+            def self.#{name}=(value)
+              ActiveSupport::Deprecation.warn "##{name} is deprecated and has no effect"
+            end
+
+            def #{name}=(value)
+              ActiveSupport::Deprecation.warn "##{name} is deprecated and has no effect"
+            end
+
+            def #{name}
+              ActiveSupport::Deprecation.warn "##{name} is deprecated and has no effect"
+            end
+          RUBY
+        end
+
         def configure
           yield self
         end
@@ -122,17 +186,20 @@ module CarrierWave
               :fog  => "CarrierWave::Storage::Fog"
             }
             config.storage = :file
+            config.cache_storage = nil
             config.fog_attributes = {}
             config.fog_credentials = {}
             config.fog_public = true
             config.fog_authenticated_url_expiration = 600
             config.fog_use_ssl_for_aws = true
+            config.fog_aws_accelerate = false
             config.store_dir = 'uploads'
             config.cache_dir = 'uploads/tmp'
             config.delete_tmp_file_after_storage = true
             config.move_to_cache = false
             config.move_to_store = false
             config.remove_previously_stored_files_after_update = true
+            config.downloader = CarrierWave::Downloader::Base
             config.ignore_integrity_errors = true
             config.ignore_processing_errors = true
             config.ignore_download_errors = true
@@ -150,4 +217,3 @@ module CarrierWave
     end
   end
 end
-

data/lib/carrierwave/uploader/content_type_blacklist.rb

@@ -0,0 +1,48 @@
+module CarrierWave
+  module Uploader
+    module ContentTypeBlacklist
+      extend ActiveSupport::Concern
+
+      included do
+        before :cache, :check_content_type_blacklist!
+      end
+
+      ##
+      # Override this method in your uploader to provide a blacklist of files content types
+      # which are not allowed to be uploaded.
+      # Not only strings but Regexp are allowed as well.
+      #
+      # === Returns
+      #
+      # [NilClass, String, Regexp, Array[String, Regexp]] a blacklist of content types which are not allowed to be uploaded
+      #
+      # === Examples
+      #
+      #     def content_type_blacklist
+      #       %w(text/json application/json)
+      #     end
+      #
+      # Basically the same, but using a Regexp:
+      #
+      #     def content_type_blacklist
+      #       [/(text|application)\/json/]
+      #     end
+      #
+      def content_type_blacklist; end
+
+    private
+
+      def check_content_type_blacklist!(new_file)
+        content_type = new_file.content_type
+        if content_type_blacklist && blacklisted_content_type?(content_type)
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.content_type_blacklist_error", content_type: content_type)
+        end
+      end
+
+      def blacklisted_content_type?(content_type)
+        Array(content_type_blacklist).any? { |item| content_type =~ /#{item}/ }
+      end
+
+    end # ContentTypeBlacklist
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/content_type_whitelist.rb

@@ -0,0 +1,48 @@
+module CarrierWave
+  module Uploader
+    module ContentTypeWhitelist
+      extend ActiveSupport::Concern
+
+      included do
+        before :cache, :check_content_type_whitelist!
+      end
+
+      ##
+      # Override this method in your uploader to provide a whitelist of files content types
+      # which are allowed to be uploaded.
+      # Not only strings but Regexp are allowed as well.
+      #
+      # === Returns
+      #
+      # [NilClass, String, Regexp, Array[String, Regexp]] a whitelist of content types which are allowed to be uploaded
+      #
+      # === Examples
+      #
+      #     def content_type_whitelist
+      #       %w(text/json application/json)
+      #     end
+      #
+      # Basically the same, but using a Regexp:
+      #
+      #     def content_type_whitelist
+      #       [/(text|application)\/json/]
+      #     end
+      #
+      def content_type_whitelist; end
+
+    private
+
+      def check_content_type_whitelist!(new_file)
+        content_type = new_file.content_type
+        if content_type_whitelist && !whitelisted_content_type?(content_type)
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.content_type_whitelist_error", content_type: content_type, allowed_types: Array(content_type_whitelist).join(", "))
+        end
+      end
+
+      def whitelisted_content_type?(content_type)
+        Array(content_type_whitelist).any? { |item| content_type =~ /#{item}/ }
+      end
+
+    end # ContentTypeWhitelist
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/default_url.rb

@@ -1,19 +1,17 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module DefaultUrl
 
       def url(*args)
-        super || default_url
+        super || default_url(*args)
       end
 
       ##
       # Override this method in your uploader to provide a default url
       # in case no file has been cached/stored yet.
       #
-      def default_url; end
+      def default_url(*args); end
 
     end # DefaultPath
   end # Uploader
-end # CarrierWave
+end # CarrierWave

data/lib/carrierwave/uploader/download.rb

@@ -1,7 +1,3 @@
-# encoding: utf-8
-
-require 'open-uri'
-
 module CarrierWave
   module Uploader
     module Download
@@ -11,78 +7,18 @@ module CarrierWave
       include CarrierWave::Uploader::Configuration
       include CarrierWave::Uploader::Cache
 
-      class RemoteFile
-        def initialize(uri)
-          @uri = uri
-        end
-
-        def original_filename
-          if file.meta.include? 'content-disposition'
-            match = file.meta['content-disposition'].match(/filename=(\"?)(.+)\1/)
-            return match[2] unless match.nil?
-          end
-          File.basename(file.base_uri.path)
-        end
-
-        def respond_to?(*args)
-          super or file.respond_to?(*args)
-        end
-
-        def http?
-          @uri.scheme =~ /^https?$/
-        end
-
-      private
-
-        def file
-          if @file.blank?
-            @file = Kernel.open(@uri.to_s)
-            @file = @file.is_a?(String) ? StringIO.new(@file) : @file
-          end
-          @file
-
-        rescue Exception => e
-          raise CarrierWave::DownloadError, "could not download file: #{e.message}"
-        end
-
-        def method_missing(*args, &block)
-          file.send(*args, &block)
-        end
-      end
-
-      ##
-      # Caches the file by downloading it from the given URL.
-      #
-      # === Parameters
-      #
-      # [url (String)] The URL where the remote file is stored
-      #
-      def download!(uri)
-        unless uri.blank?
-          processed_uri = process_uri(uri)
-          file = RemoteFile.new(processed_uri)
-          raise CarrierWave::DownloadError, "trying to download a file which is not served over HTTP" unless file.http?
-          cache!(file)
-        end
-      end
-
       ##
-      # Processes the given URL by parsing and escaping it. Public to allow overriding.
+      # Caches the file by downloading it from the given URL, using downloader.
       #
       # === Parameters
       #
       # [url (String)] The URL where the remote file is stored
+      # [remote_headers (Hash)] Request headers
       #
-      def process_uri(uri)
-        URI.parse(uri)
-      rescue URI::InvalidURIError
-        uri_parts = uri.split('?')
-        # regexp from Ruby's URI::Parser#regexp[:UNSAFE], with [] specifically removed
-        encoded_uri = URI.encode(uri_parts.shift, /[^\-_.!~*'()a-zA-Z\d;\/?:@&=+$,]/)
-        encoded_uri << '?' << URI.encode(uri_parts.join('?')) if uri_parts.any?
-        URI.parse(encoded_uri) rescue raise CarrierWave::DownloadError, "couldn't parse URL"
+      def download!(uri, remote_headers = {})
+        file = downloader.new(self).download(uri, remote_headers)
+        cache!(file)
       end
-
     end # Download
   end # Uploader
 end # CarrierWave

data/lib/carrierwave/uploader/extension_blacklist.rb

@@ -4,7 +4,7 @@ module CarrierWave
       extend ActiveSupport::Concern
 
       included do
-        before :cache, :check_blacklist!
+        before :cache, :check_extension_blacklist!
       end
 
       ##
@@ -16,32 +16,36 @@ module CarrierWave
       # the Regexp expression, also case insensitive.
       #
       # === Returns
-      
-      # [NilClass, Array[String,Regexp]] a black list of extensions which are prohibited to be uploaded
+
+      # [NilClass, String, Regexp, Array[String, Regexp]] a black list of extensions which are prohibited to be uploaded
       #
       # === Examples
       #
-      #     def extension_black_list
+      #     def extension_blacklist
       #       %w(swf tiff)
       #     end
       #
       # Basically the same, but using a Regexp:
       #
-      #     def extension_black_list
+      #     def extension_blacklist
       #       [/swf/, 'tiff']
       #     end
       #
- 
-      def extension_black_list; end
+
+      def extension_blacklist; end
 
     private
 
-      def check_blacklist!(new_file)
+      def check_extension_blacklist!(new_file)
         extension = new_file.extension.to_s
-        if extension_black_list and extension_black_list.detect { |item| extension =~ /\A#{item}\z/i }
-          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.extension_black_list_error", :extension => new_file.extension.inspect, :prohibited_types => extension_black_list.join(", "))
+        if extension_blacklist && blacklisted_extension?(extension)
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.extension_blacklist_error", extension: new_file.extension.inspect, prohibited_types: Array(extension_blacklist).join(", "))
         end
       end
+
+      def blacklisted_extension?(extension)
+        Array(extension_blacklist).any? { |item| extension =~ /\A#{item}\z/i }
+      end
     end
   end
 end

data/lib/carrierwave/uploader/extension_whitelist.rb

@@ -1,12 +1,10 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module ExtensionWhitelist
       extend ActiveSupport::Concern
 
       included do
-        before :cache, :check_whitelist!
+        before :cache, :check_extension_whitelist!
       end
 
       ##
@@ -19,31 +17,36 @@ module CarrierWave
       #
       # === Returns
       #
-      # [NilClass, Array[String,Regexp]] a white list of extensions which are allowed to be uploaded
+      # [NilClass, String, Regexp, Array[String, Regexp]] a white list of extensions which are allowed to be uploaded
       #
       # === Examples
       #
-      #     def extension_white_list
+      #     def extension_whitelist
       #       %w(jpg jpeg gif png)
       #     end
       #
       # Basically the same, but using a Regexp:
       #
-      #     def extension_white_list
+      #     def extension_whitelist
       #       [/jpe?g/, 'gif', 'png']
       #     end
       #
-      def extension_white_list; end
+      def extension_whitelist; end
 
     private
 
-      def check_whitelist!(new_file)
+      def check_extension_whitelist!(new_file)
         extension = new_file.extension.to_s
-        if extension_white_list and not extension_white_list.detect { |item| extension =~ /\A#{item}\z/i }
-          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.extension_white_list_error", :extension => new_file.extension.inspect, :allowed_types => extension_white_list.join(", "))
+        if extension_whitelist && !whitelisted_extension?(extension)
+          raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.extension_whitelist_error", extension: new_file.extension.inspect, allowed_types: Array(extension_whitelist).join(", "))
         end
       end
 
+      def whitelisted_extension?(extension)
+        downcase_extension = extension.downcase
+        Array(extension_whitelist).any? { |item| downcase_extension =~ /\A#{item}\z/i }
+      end
+
     end # ExtensionWhitelist
   end # Uploader
 end # CarrierWave