carrierwave 0.11.0 → 1.0.0

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)
+        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,5 +1,3 @@
-# encoding: utf-8
-
 require 'open-uri'
 
 module CarrierWave
@@ -12,8 +10,9 @@ module CarrierWave
       include CarrierWave::Uploader::Cache
 
       class RemoteFile
-        def initialize(uri)
+        def initialize(uri, remote_headers = {})
           @uri = uri
+          @remote_headers = remote_headers
         end
 
         def original_filename
@@ -37,12 +36,15 @@ module CarrierWave
 
         def file
           if @file.blank?
-            @file = Kernel.open(@uri.to_s)
+            headers = @remote_headers.
+              reverse_merge('User-Agent' => "CarrierWave/#{CarrierWave::VERSION}")
+
+            @file = Kernel.open(@uri.to_s, headers)
             @file = @file.is_a?(String) ? StringIO.new(@file) : @file
           end
           @file
 
-        rescue Exception => e
+        rescue StandardError => e
           raise CarrierWave::DownloadError, "could not download file: #{e.message}"
         end
 
@@ -64,10 +66,11 @@ module CarrierWave
       # === Parameters
       #
       # [url (String)] The URL where the remote file is stored
+      # [remote_headers (Hash)] Request headers
       #
-      def download!(uri)
+      def download!(uri, remote_headers = {})
         processed_uri = process_uri(uri)
-        file = RemoteFile.new(processed_uri)
+        file = RemoteFile.new(processed_uri, remote_headers)
         raise CarrierWave::DownloadError, "trying to download a file which is not served over HTTP" unless file.http?
         cache!(file)
       end

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,35 @@ 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)
+        Array(extension_whitelist).any? { |item| extension =~ /\A#{item}\z/i }
+      end
+
     end # ExtensionWhitelist
   end # Uploader
 end # CarrierWave

data/lib/carrierwave/uploader/file_size.rb

@@ -0,0 +1,41 @@
+module CarrierWave
+  module Uploader
+    module FileSize
+      extend ActiveSupport::Concern
+
+      included do
+        before :cache, :check_size!
+      end
+
+      ##
+      # Override this method in your uploader to provide a Range of Size which
+      # are allowed to be uploaded.
+      # === Returns
+      #
+      # [NilClass, Range] a size range which are permitted to be uploaded
+      #
+      # === Examples
+      #
+      #     def size_range
+      #       3256...5748
+      #     end
+      #
+      def size_range; end
+
+      private
+
+      def check_size!(new_file)
+        size = new_file.size
+        expected_size_range = size_range
+        if expected_size_range.is_a?(::Range)
+          if size < expected_size_range.min
+            raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.min_size_error", :min_size => expected_size_range.min)
+          elsif size > expected_size_range.max
+            raise CarrierWave::IntegrityError, I18n.translate(:"errors.messages.max_size_error", :max_size => expected_size_range.max)
+          end
+        end
+      end
+
+    end # FileSize
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/magic_mime_blacklist.rb

@@ -0,0 +1,94 @@
+module CarrierWave
+  module Uploader
+
+    ##
+    # This modules validates the content type of a file with the use of
+    # ruby-filemagic gem and a blacklist regular expression. If you want
+    # to use this, you'll need to require this file:
+    #
+    #   require 'carrierwave/uploader/magic_mime_blacklist'
+    #
+    # And then include it in your uploader:
+    #
+    #   class MyUploader < CarrierWave::Uploader::Base
+    #     include CarrierWave::Uploader::MagicMimeBlacklist
+    #
+    #     def blacklist_mime_type_pattern
+    #       /image\//
+    #     end
+    #   end
+    #
+    module MagicMimeBlacklist
+      extend ActiveSupport::Concern
+
+      included do
+        begin
+          require "filemagic"
+        rescue LoadError => e
+          e.message << " (You may need to install the ruby-filemagic gem)"
+          raise e
+        end
+
+        before :cache, :check_blacklist_pattern!
+      end
+
+      ##
+      # Override this method in your uploader to provide a black list pattern (regexp)
+      # of content-types which are prohibited to be uploaded.
+      # Compares the file's content-type.
+      #
+      # === Returns
+      #
+      # [Regexp] a black list regexp to match the content_type
+      #
+      # === Examples
+      #
+      #     def blacklist_mime_type_pattern
+      #       /(text|application)\/json/
+      #     end
+      #
+      def blacklist_mime_type_pattern; end
+
+    private
+
+      def check_blacklist_pattern!(new_file)
+        return if blacklist_mime_type_pattern.nil?
+
+        content_type = extract_content_type(new_file)
+
+        if content_type.match(blacklist_mime_type_pattern)
+          raise CarrierWave::IntegrityError,
+            I18n.translate(:"errors.messages.mime_type_pattern_black_list_error",
+                           :content_type => content_type)
+        end
+      end
+
+      ##
+      # Extracts the content type of the given file
+      #
+      # === Returns
+      #
+      # [String] the extracted content type
+      #
+      def extract_content_type(new_file)
+        content_type = nil
+
+        File.open(new_file.path) do |fd|
+          data = fd.read(1024) || ""
+          content_type = filemagic.buffer(data)
+        end
+
+        content_type
+      end
+
+    ##
+    # FileMagic object with the MAGIC_MIME_TYPE flag set
+    #
+    # @return [FileMagic] a filemagic object
+      def filemagic
+        @filemagic ||= FileMagic.new(FileMagic::MAGIC_MIME_TYPE)
+      end
+
+    end # MagicMimeblackList
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/magic_mime_whitelist.rb

@@ -0,0 +1,94 @@
+module CarrierWave
+  module Uploader
+
+    ##
+    # This modules validates the content type of a file with the use of
+    # ruby-filemagic gem and a whitelist regular expression. If you want
+    # to use this, you'll need to require this file:
+    #
+    #   require 'carrierwave/uploader/magic_mime_whitelist'
+    #
+    # And then include it in your uploader:
+    #
+    #   class MyUploader < CarrierWave::Uploader::Base
+    #     include CarrierWave::Uploader::MagicMimeWhitelist
+    #
+    #     def whitelist_mime_type_pattern
+    #       /image\//
+    #     end
+    #   end
+    #
+    module MagicMimeWhitelist
+      extend ActiveSupport::Concern
+
+      included do
+        begin
+          require "filemagic"
+        rescue LoadError => e
+          e.message << " (You may need to install the ruby-filemagic gem)"
+          raise e
+        end
+
+        before :cache, :check_whitelist_pattern!
+      end
+
+      ##
+      # Override this method in your uploader to provide a white list pattern (regexp)
+      # of content-types which are allowed to be uploaded.
+      # Compares the file's content-type.
+      #
+      # === Returns
+      #
+      # [Regexp] a white list regexp to match the content_type
+      #
+      # === Examples
+      #
+      #     def whitelist_mime_type_pattern
+      #       /(text|application)\/json/
+      #     end
+      #
+      def whitelist_mime_type_pattern; end
+
+    private
+
+      def check_whitelist_pattern!(new_file)
+        return if whitelist_mime_type_pattern.nil?
+
+        content_type = extract_content_type(new_file)
+
+        if !content_type.match(whitelist_mime_type_pattern)
+          raise CarrierWave::IntegrityError,
+            I18n.translate(:"errors.messages.mime_type_pattern_white_list_error",
+                           :content_type => content_type)
+        end
+      end
+
+      ##
+      # Extracts the content type of the given file
+      #
+      # === Returns
+      #
+      # [String] the extracted content type
+      #
+      def extract_content_type(new_file)
+        content_type = nil
+
+        File.open(new_file.path) do |fd|
+          data = fd.read(1024) || ""
+          content_type = filemagic.buffer(data)
+        end
+
+        content_type
+      end
+
+    ##
+    # FileMagic object with the MAGIC_MIME_TYPE flag set
+    #
+    # @return [FileMagic] a filemagic object
+      def filemagic
+        @filemagic ||= FileMagic.new(FileMagic::MAGIC_MIME_TYPE)
+      end
+
+    end # MagicMimeWhiteList
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/mountable.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module Mountable
@@ -7,13 +5,14 @@ module CarrierWave
       attr_reader :model, :mounted_as
 
       ##
-      # If a model is given as the first parameter, it will be stored in the uploader, and
-      # available throught +#model+. Likewise, mounted_as stores the name of the column
-      # where this instance of the uploader is mounted. These values can then be used inside
-      # your uploader.
+      # If a model is given as the first parameter, it will be stored in the
+      # uploader, and available through +#model+. Likewise, mounted_as stores
+      # the name of the column where this instance of the uploader is mounted.
+      # These values can then be used inside your uploader.
       #
-      # If you do not wish to mount your uploaders with the ORM extensions in -more then you
-      # can override this method inside your uploader. Just be sure to call +super+
+      # If you do not wish to mount your uploaders with the ORM extensions in
+      # -more then you can override this method inside your uploader. Just be
+      # sure to call +super+
       #
       # === Parameters
       #

data/lib/carrierwave/uploader/processing.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module Processing
@@ -11,7 +9,7 @@ module CarrierWave
         class_attribute :processors, :instance_writer => false
         self.processors = []
 
-        after :cache, :process!
+        before :cache, :process!
       end
 
       module ClassMethods

data/lib/carrierwave/uploader/proxy.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module Proxy
@@ -19,7 +17,7 @@ module CarrierWave
       # [String] the path where the file is currently located.
       #
       def current_path
-        file.path if file.respond_to?(:path)
+        file.try(:path)
       end
 
       alias_method :path, :current_path
@@ -32,7 +30,7 @@ module CarrierWave
       # [String] uniquely identifies a file
       #
       def identifier
-        storage.identifier if storage.respond_to?(:identifier)
+        storage.try(:identifier)
       end
 
       ##
@@ -43,7 +41,7 @@ module CarrierWave
       # [String] contents of the file
       #
       def read
-        file.read if file.respond_to?(:read)
+        file.try(:read)
       end
 
       ##
@@ -54,7 +52,7 @@ module CarrierWave
       # [Integer] size of the file
       #
       def size
-        file.respond_to?(:size) ? file.size : 0
+        file.try(:size) || 0
       end
 
       ##
@@ -80,7 +78,7 @@ module CarrierWave
       # [String] content type of the file
       #
       def content_type
-        file.respond_to?(:content_type) ? file.content_type : nil
+        file.try(:content_type)
       end
 
     end # Proxy

data/lib/carrierwave/uploader/remove.rb

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

data/lib/carrierwave/uploader/serialization.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require "json"
 require "active_support/core_ext/hash"
 
@@ -13,7 +11,7 @@ module CarrierWave
       end
 
       def as_json(options=nil)
-        Hash[mounted_as || "uploader", serializable_hash]
+        serializable_hash
       end
 
       def to_json(options=nil)

data/lib/carrierwave/uploader/store.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module Store
@@ -54,35 +52,19 @@ module CarrierWave
       #
       def store!(new_file=nil)
         cache!(new_file) if new_file && ((@cache_id != parent_cache_id) || @cache_id.nil?)
-        if @file and @cache_id
+        if !cache_only and @file and @cache_id
           with_callbacks(:store, new_file) do
             new_file = storage.store!(@file)
-            @file.delete if (delete_tmp_file_after_storage && ! move_to_store)
-            delete_cache_id
+            if delete_tmp_file_after_storage
+              @file.delete unless move_to_store
+              cache_storage.delete_dir!(cache_path(nil))
+            end
             @file = new_file
             @cache_id = nil
           end
         end
       end
 
-      ##
-      # Deletes a cache id (tmp dir in cache)
-      #
-      def delete_cache_id
-        if @cache_id
-          path = File.expand_path(File.join(cache_dir, @cache_id), CarrierWave.root)
-          begin
-            Dir.rmdir(path)
-          rescue Errno::ENOENT
-            # Ignore: path does not exist
-          rescue Errno::ENOTDIR
-            # Ignore: path is not a dir
-          rescue Errno::ENOTEMPTY, Errno::EEXIST
-            # Ignore: dir is not empty
-          end
-        end
-      end
-
       ##
       # Retrieves the file from the storage.
       #

data/lib/carrierwave/uploader/url.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Uploader
     module Url
@@ -20,7 +18,7 @@ module CarrierWave
         if file.respond_to?(:url) and not file.url.blank?
           file.method(:url).arity == 0 ? file.url : file.url(options)
         elsif file.respond_to?(:path)
-          path = encode_path(file.path.gsub(File.expand_path(root), ''))
+          path = encode_path(file.path.sub(File.expand_path(root), ''))
 
           if host = asset_host
             if host.respond_to? :call