carrierwave 0.11.2 → 2.1.0

data/lib/carrierwave/processing/rmagick.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
 
   ##
@@ -69,6 +67,13 @@ module CarrierWave
         e.message << " (You may need to install the rmagick gem)"
         raise e
       end
+
+      prepend Module.new {
+        def initialize(*)
+          super
+          @format = nil
+        end
+      }
     end
 
     module ClassMethods
@@ -135,6 +140,8 @@ module CarrierWave
     # [Magick::Image] additional manipulations to perform
     #
     def resize_to_limit(width, height)
+      width = dimension_from width
+      height = dimension_from height
       manipulate! do |img|
         geometry = Magick::Geometry.new(width, height, 0, 0, Magick::GreaterGeometry)
         new_img = img.change_geometry(geometry) do |new_width, new_height|
@@ -164,6 +171,8 @@ module CarrierWave
     # [Magick::Image] additional manipulations to perform
     #
     def resize_to_fit(width, height)
+      width = dimension_from width
+      height = dimension_from height
       manipulate! do |img|
         img.resize_to_fit!(width, height)
         img = yield(img) if block_given?
@@ -188,6 +197,8 @@ module CarrierWave
     # [Magick::Image] additional manipulations to perform
     #
     def resize_to_fill(width, height, gravity=::Magick::CenterGravity)
+      width = dimension_from width
+      height = dimension_from height
       manipulate! do |img|
         img.crop_resized!(width, height, gravity)
         img = yield(img) if block_given?
@@ -213,6 +224,8 @@ module CarrierWave
     # [Magick::Image] additional manipulations to perform
     #
     def resize_and_pad(width, height, background=:transparent, gravity=::Magick::CenterGravity)
+      width = dimension_from width
+      height = dimension_from height
       manipulate! do |img|
         img.resize_to_fit!(width, height)
         new_img = ::Magick::Image.new(width, height) { self.background_color = background == :transparent ? 'rgba(255,255,255,0)' : background.to_s }
@@ -251,6 +264,28 @@ module CarrierWave
       end
     end
 
+    ##
+    # Returns the width of the image.
+    #
+    # === Returns
+    #
+    # [Integer] the image's width in pixels
+    #
+    def width
+      rmagick_image.columns
+    end
+
+    ##
+    # Returns the height of the image.
+    #
+    # === Returns
+    #
+    # [Integer] the image's height in pixels
+    #
+    def height
+      rmagick_image.rows
+    end
+
     ##
     # Manipulate the image with RMagick. This method will load up an image
     # and then pass each of its frames to the supplied block. It will then
@@ -318,20 +353,25 @@ module CarrierWave
       frames = ::Magick::ImageList.new
 
       image.each_with_index do |frame, index|
-        frame = yield *[frame, index, options].take(block.arity) if block_given?
+        frame = yield(*[frame, index, options].take(block.arity)) if block_given?
         frames << frame if frame
       end
       frames.append(true) if block_given?
 
       write_block = create_info_block(options[:write])
+
       if options[:format] || @format
         frames.write("#{options[:format] || @format}:#{current_path}", &write_block)
+        move_to = current_path.chomp(File.extname(current_path)) + ".#{options[:format] || @format}"
+        file.content_type = ::MiniMime.lookup_by_filename(move_to).content_type
+        file.move_to(move_to, permissions, directory_permissions)
       else
         frames.write(current_path, &write_block)
       end
+
       destroy_image(frames)
     rescue ::Magick::ImageMagickError => e
-      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.rmagick_processing_error", :e => e, :default => I18n.translate(:"errors.messages.rmagick_processing_error", :e => e, :locale => :en))
+      raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.rmagick_processing_error", :e => e)
     end
 
   private
@@ -344,7 +384,16 @@ module CarrierWave
     end
 
     def destroy_image(image)
-      image.destroy! if image.respond_to?(:destroy!)
+      image.try(:destroy!)
+    end
+
+    def dimension_from(value)
+      return value unless value.instance_of?(Proc)
+      value.arity >= 1 ? value.call(self) : value.call
+    end
+
+    def rmagick_image
+      ::Magick::Image.from_blob(self.read).first
     end
 
   end # RMagick

data/lib/carrierwave/sanitized_file.rb

@@ -1,8 +1,6 @@
-# encoding: utf-8
-
 require 'pathname'
 require 'active_support/core_ext/string/multibyte'
-require 'mime/types'
+require 'mini_mime'
 require 'mimemagic'
 
 module CarrierWave
@@ -17,18 +15,19 @@ module CarrierWave
   #
   class SanitizedFile
 
-    attr_accessor :file
+    attr_reader :file
 
     class << self
       attr_writer :sanitize_regexp
 
       def sanitize_regexp
-        @sanitize_regexp ||= /[^a-zA-Z0-9\.\-\+_]/
+        @sanitize_regexp ||= /[^[:word:]\.\-\+]/
       end
     end
 
     def initialize(file)
       self.file = file
+      @content = nil
     end
 
     ##
@@ -110,12 +109,11 @@ module CarrierWave
     # [String, nil] the path where the file is located.
     #
     def path
-      unless @file.blank?
-        if is_path?
-          File.expand_path(@file)
-        elsif @file.respond_to?(:path) and not @file.path.blank?
-          File.expand_path(@file.path)
-        end
+      return if @file.blank?
+      if is_path?
+        File.expand_path(@file)
+      elsif @file.respond_to?(:path) && !@file.path.blank?
+        File.expand_path(@file.path)
       end
     end
 
@@ -143,8 +141,7 @@ module CarrierWave
     # [Boolean] Whether the file exists
     #
     def exists?
-      return File.exists?(self.path) if self.path
-      return false
+      self.path.present? && File.exist?(self.path)
     end
 
     ##
@@ -160,9 +157,9 @@ module CarrierWave
       elsif is_path?
         File.open(@file, "rb") {|file| file.read}
       else
-        @file.rewind if @file.respond_to?(:rewind)
+        @file.try(:rewind)
         @content = @file.read
-        @file.close if @file.respond_to?(:close) && @file.respond_to?(:closed?) && !@file.closed?
+        @file.try(:close) unless @file.try(:closed?)
         @content
       end
     end
@@ -176,19 +173,29 @@ module CarrierWave
     # [permissions (Integer)] permissions to set on the file in its new location.
     # [directory_permissions (Integer)] permissions to set on created directories.
     #
-    def move_to(new_path, permissions=nil, directory_permissions=nil)
+    def move_to(new_path, permissions=nil, directory_permissions=nil, keep_filename=false)
       return if self.empty?
       new_path = File.expand_path(new_path)
 
       mkdir!(new_path, directory_permissions)
+      move!(new_path)
+      chmod!(new_path, permissions)
+      if keep_filename
+        self.file = {:tempfile => new_path, :filename => original_filename, :content_type => content_type}
+      else
+        self.file = {:tempfile => new_path, :content_type => content_type}
+      end
+      self
+    end
+    ##
+    # Helper to move file to new path.
+    #
+    def move!(new_path)
       if exists?
-        FileUtils.mv(path, new_path) unless new_path == path
+        FileUtils.mv(path, new_path) unless File.identical?(new_path, path)
       else
         File.open(new_path, "wb") { |f| f.write(read) }
       end
-      chmod!(new_path, permissions)
-      self.file = new_path
-      self
     end
 
     ##
@@ -209,13 +216,20 @@ module CarrierWave
       new_path = File.expand_path(new_path)
 
       mkdir!(new_path, directory_permissions)
+      copy!(new_path)
+      chmod!(new_path, permissions)
+      self.class.new({:tempfile => new_path, :content_type => content_type})
+    end
+
+    ##
+    # Helper to create copy of file in new path.
+    #
+    def copy!(new_path)
       if exists?
         FileUtils.cp(path, new_path) unless new_path == path
       else
         File.open(new_path, "wb") { |f| f.write(read) }
       end
-      chmod!(new_path, permissions)
-      self.class.new({:tempfile => new_path, :content_type => content_type})
     end
 
     ##
@@ -248,7 +262,7 @@ module CarrierWave
       @content_type ||=
         existing_content_type ||
         mime_magic_content_type ||
-        mime_types_content_type
+        mini_mime_content_type
     end
 
     ##
@@ -279,7 +293,7 @@ module CarrierWave
       if file.is_a?(Hash)
         @file = file["tempfile"] || file[:tempfile]
         @original_filename = file["filename"] || file[:filename]
-        @content_type = file["content_type"] || file[:content_type]
+        @content_type = file["content_type"] || file[:content_type] || file["type"] || file[:type]
       else
         @file = file
         @original_filename = nil
@@ -291,7 +305,7 @@ module CarrierWave
     def mkdir!(path, directory_permissions)
       options = {}
       options[:mode] = directory_permissions if directory_permissions
-      FileUtils.mkdir_p(File.dirname(path), options) unless File.exists?(File.dirname(path))
+      FileUtils.mkdir_p(File.dirname(path), **options) unless File.exist?(File.dirname(path))
     end
 
     def chmod!(path, permissions)
@@ -300,11 +314,11 @@ module CarrierWave
 
     # Sanitize the filename, to prevent hacking
     def sanitize(name)
-      name = name.gsub("\\", "/") # work-around for IE
+      name = name.tr("\\", "/") # work-around for IE
       name = File.basename(name)
       name = name.gsub(sanitize_regexp,"_")
       name = "_#{name}" if name =~ /\A\.+\z/
-      name = "unnamed" if name.size == 0
+      name = "unnamed" if name.size.zero?
       return name.mb_chars.to_s
     end
 
@@ -315,13 +329,19 @@ module CarrierWave
     end
 
     def mime_magic_content_type
-      MimeMagic.by_magic(File.open(path)).try(:type) if path
+      if path
+        File.open(path) do |file|
+          MimeMagic.by_magic(file).try(:type) || 'invalid/invalid'
+        end
+      end
     rescue Errno::ENOENT
       nil
     end
 
-    def mime_types_content_type
-      ::MIME::Types.type_for(path).first.to_s if path
+    def mini_mime_content_type
+      return unless path
+      mime_type = ::MiniMime.lookup_by_filename(path)
+      @content_type = (mime_type && mime_type.content_type).to_s
     end
 
     def split_extension(filename)

data/lib/carrierwave/storage.rb

@@ -1,11 +1,3 @@
 require "carrierwave/storage/abstract"
 require "carrierwave/storage/file"
-
-%w(aws google openstack rackspace).each do |fog_dependency|
-  begin
-    require "fog/#{fog_dependency}"
-  rescue LoadError
-  end
-end
-
-require "carrierwave/storage/fog" if defined?(Fog)
+require "carrierwave/storage/fog"

data/lib/carrierwave/storage/abstract.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Storage
 
@@ -25,6 +23,21 @@ module CarrierWave
       def retrieve!(identifier)
       end
 
+      def cache!(new_file)
+        raise NotImplementedError.new("Need to implement #cache! if you want to use #{self.class.name} as a cache storage.")
+      end
+
+      def retrieve_from_cache!(identifier)
+        raise NotImplementedError.new("Need to implement #retrieve_from_cache! if you want to use #{self.class.name} as a cache storage.")
+      end
+
+      def delete_dir!(path)
+        raise NotImplementedError.new("Need to implement #delete_dir! if you want to use #{self.class.name} as a cache storage.")
+      end
+
+      def clean_cache!(seconds)
+        raise NotImplementedError.new("Need to implement #clean_cache! if you want to use #{self.class.name} as a cache storage.")
+      end
     end # Abstract
   end # Storage
 end # CarrierWave

data/lib/carrierwave/storage/file.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Storage
 
@@ -9,6 +7,10 @@ module CarrierWave
     # pretty much it.
     #
     class File < Abstract
+      def initialize(*)
+        super
+        @cache_called = nil
+      end
 
       ##
       # Move the file to the uploader's store path.
@@ -51,6 +53,71 @@ module CarrierWave
         CarrierWave::SanitizedFile.new(path)
       end
 
+      ##
+      # Stores given file to cache directory.
+      #
+      # === Parameters
+      #
+      # [new_file (File, IOString, Tempfile)] any kind of file object
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def cache!(new_file)
+        new_file.move_to(::File.expand_path(uploader.cache_path, uploader.root), uploader.permissions, uploader.directory_permissions, true)
+      rescue Errno::EMLINK, Errno::ENOSPC => e
+        raise(e) if @cache_called
+        @cache_called = true
+
+        # NOTE: Remove cached files older than 10 minutes
+        clean_cache!(600)
+
+        cache!(new_file)
+      end
+
+      ##
+      # Retrieves the file with the given cache_name from the cache.
+      #
+      # === Parameters
+      #
+      # [cache_name (String)] uniquely identifies a cache file
+      #
+      # === Raises
+      #
+      # [CarrierWave::InvalidParameter] if the cache_name is incorrectly formatted.
+      #
+      def retrieve_from_cache!(identifier)
+        CarrierWave::SanitizedFile.new(::File.expand_path(uploader.cache_path(identifier), uploader.root))
+      end
+
+      ##
+      # Deletes a cache dir
+      #
+      def delete_dir!(path)
+        if path
+          begin
+            Dir.rmdir(::File.expand_path(path, uploader.root))
+          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
+
+      def clean_cache!(seconds)
+        Dir.glob(::File.expand_path(::File.join(uploader.cache_dir, '*'), CarrierWave.root)).each do |dir|
+          # generate_cache_id returns key formated TIMEINT-PID(-COUNTER)-RND
+          time = dir.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first.map(&:to_i)
+          time = Time.at(*time)
+          if time < (Time.now.utc - seconds)
+            FileUtils.rm_rf(dir)
+          end
+        end
+      end
     end # File
   end # Storage
 end # CarrierWave

data/lib/carrierwave/storage/fog.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module CarrierWave
   module Storage
 
@@ -18,6 +16,8 @@ module CarrierWave
     # [:fog_authenticated_url_expiration] (optional) time (in seconds) that authenticated urls
     #   will be valid, when fog_public is false and provider is AWS or Google, defaults to 600
     # [:fog_use_ssl_for_aws]              (optional) #public_url will use https for the AWS generated URL]
+    # [:fog_aws_accelerate]               (optional) #public_url will use s3-accelerate subdomain
+    #   instead of s3, defaults to false
     #
     #
     # AWS credentials contain the following keys:
@@ -25,7 +25,7 @@ module CarrierWave
     # [:aws_access_key_id]
     # [:aws_secret_access_key]
     # [:region]                 (optional) defaults to 'us-east-1'
-    #   :region should be one of ['eu-west-1', 'us-east-1', 'ap-southeast-1', 'us-west-1', 'ap-northeast-1']
+    #   :region should be one of ['eu-west-1', 'us-east-1', 'ap-southeast-1', 'us-west-1', 'ap-northeast-1', 'eu-central-1']
     #
     #
     # Google credentials contain the following keys:
@@ -60,6 +60,14 @@ module CarrierWave
         def connection_cache
           @connection_cache ||= {}
         end
+
+        def eager_load
+          # see #1198. This will hopefully no longer be necessary in future release of fog
+          fog_credentials = CarrierWave::Uploader::Base.fog_credentials
+          if fog_credentials.present?
+            CarrierWave::Storage::Fog.connection_cache[fog_credentials] ||= ::Fog::Storage.new(fog_credentials)
+          end
+        end
       end
 
       ##
@@ -94,6 +102,57 @@ module CarrierWave
         CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path(identifier))
       end
 
+      ##
+      # Stores given file to cache directory.
+      #
+      # === Parameters
+      #
+      # [new_file (File, IOString, Tempfile)] any kind of file object
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def cache!(new_file)
+        f = CarrierWave::Storage::Fog::File.new(uploader, self, uploader.cache_path)
+        f.store(new_file)
+        f
+      end
+
+      ##
+      # Retrieves the file with the given cache_name from the cache.
+      #
+      # === Parameters
+      #
+      # [cache_name (String)] uniquely identifies a cache file
+      #
+      # === Raises
+      #
+      # [CarrierWave::InvalidParameter] if the cache_name is incorrectly formatted.
+      #
+      def retrieve_from_cache!(identifier)
+        CarrierWave::Storage::Fog::File.new(uploader, self, uploader.cache_path(identifier))
+      end
+
+      ##
+      # Deletes a cache dir
+      #
+      def delete_dir!(path)
+        # do nothing, because there's no such things as 'empty directory'
+      end
+
+      def clean_cache!(seconds)
+        connection.directories.new(
+          :key    => uploader.fog_directory,
+          :public => uploader.fog_public
+        ).files.all(:prefix => uploader.cache_dir).each do |file|
+          # generate_cache_id returns key formated TIMEINT-PID(-COUNTER)-RND
+          time = file.key.scan(/(\d+)-\d+-\d+(?:-\d+)?/).first.map { |t| t.to_i }
+          time = Time.at(*time)
+          file.destroy if time < (Time.now.utc - seconds)
+        end
+      end
+
       def connection
         @connection ||= begin
           options = credentials = uploader.fog_credentials
@@ -102,6 +161,8 @@ module CarrierWave
       end
 
       class File
+        DEFAULT_S3_REGION = 'us-east-1'
+
         include CarrierWave::Utilities::Uri
 
         ##
@@ -126,7 +187,7 @@ module CarrierWave
 
         ##
         # Return a temporary authenticated url to a private file, if available
-        # Only supported for AWS, Rackspace and Google providers
+        # Only supported for AWS, Rackspace, Google, AzureRM and Aliyun providers
         #
         # === Returns
         #
@@ -135,19 +196,28 @@ module CarrierWave
         # [NilClass] no authenticated url available
         #
         def authenticated_url(options = {})
-          if ['AWS', 'Google', 'Rackspace', 'OpenStack'].include?(@uploader.fog_credentials[:provider])
+          if ['AWS', 'Google', 'Rackspace', 'OpenStack', 'AzureRM', 'Aliyun', 'backblaze'].include?(@uploader.fog_credentials[:provider])
             # avoid a get by using local references
             local_directory = connection.directories.new(:key => @uploader.fog_directory)
             local_file = local_directory.files.new(:key => path)
-            if @uploader.fog_credentials[:provider] == "AWS"
-              local_file.url(::Fog::Time.now + @uploader.fog_authenticated_url_expiration, options)
-            elsif ['Rackspace', 'OpenStack'].include?(@uploader.fog_credentials[:provider])
-              connection.get_object_https_url(@uploader.fog_directory, path, ::Fog::Time.now + @uploader.fog_authenticated_url_expiration)
-            else
-              local_file.url(::Fog::Time.now + @uploader.fog_authenticated_url_expiration)
+            expire_at = options[:expire_at] || ::Fog::Time.now + @uploader.fog_authenticated_url_expiration
+            case @uploader.fog_credentials[:provider]
+              when 'AWS', 'Google'
+                # Older versions of fog-google do not support options as a parameter
+                if url_options_supported?(local_file)
+                  local_file.url(expire_at, options)
+                else
+                  warn "Options hash not supported in #{local_file.class}. You may need to upgrade your Fog provider."
+                  local_file.url(expire_at)
+                end
+              when 'Rackspace', 'OpenStack'
+                connection.get_object_https_url(@uploader.fog_directory, path, expire_at, options)
+              when 'Aliyun'
+                expire_at = expire_at - Time.now
+                local_file.url(expire_at)
+              else
+                local_file.url(expire_at)
             end
-          else
-            nil
           end
         end
 
@@ -159,7 +229,7 @@ module CarrierWave
         # [String] value of content-type
         #
         def content_type
-          @content_type || file.content_type
+          @content_type || file.try(:content_type)
         end
 
         ##
@@ -182,7 +252,9 @@ module CarrierWave
         #
         def delete
           # avoid a get by just using local reference
-          directory.files.new(:key => path).destroy
+          directory.files.new(:key => path).destroy.tap do |result|
+            @file = nil if result
+          end
         end
 
         ##
@@ -213,7 +285,7 @@ module CarrierWave
         end
 
         def initialize(uploader, base, path)
-          @uploader, @base, @path = uploader, base, path
+          @uploader, @base, @path, @content_type = uploader, base, path, nil
         end
 
         ##
@@ -223,6 +295,16 @@ module CarrierWave
         #
         # [String] contents of file
         def read
+          file_body = file.body
+
+          return if file_body.nil?
+          return file_body unless file_body.is_a?(::File)
+
+          # Fog::Storage::XXX::File#body could return the source file which was upoloaded to the remote server.
+          read_source_file(file_body) if ::File.exist?(file_body.path)
+
+          # If the source file doesn't exist, the remote content is read
+          @file = nil # rubocop:disable Gitlab/ModuleWithInstanceVariables
           file.body
         end
 
@@ -234,7 +316,7 @@ module CarrierWave
         # [Integer] size of file body
         #
         def size
-          file.content_length
+          file.nil? ? 0 : file.content_length
         end
 
         ##
@@ -244,7 +326,7 @@ module CarrierWave
         #
         # [Boolean] true if file exists or false
         def exists?
-          !!directory.files.head(path)
+          !!file
         end
 
         ##
@@ -254,15 +336,19 @@ module CarrierWave
         #
         # [Boolean] true on success or raises error
         def store(new_file)
-          fog_file = new_file.to_file
-          @content_type ||= new_file.content_type
-          @file = directory.files.create({
-            :body         => fog_file ? fog_file : new_file.read,
-            :content_type => @content_type,
-            :key          => path,
-            :public       => @uploader.fog_public
-          }.merge(@uploader.fog_attributes))
-          fog_file.close if fog_file && !fog_file.closed?
+          if new_file.is_a?(self.class)
+            new_file.copy_to(path)
+          else
+            fog_file = new_file.to_file
+            @content_type ||= new_file.content_type
+            @file = directory.files.create({
+              :body         => fog_file ? fog_file : new_file.read,
+              :content_type => @content_type,
+              :key          => path,
+              :public       => @uploader.fog_public
+            }.merge(@uploader.fog_attributes))
+            fog_file.close if fog_file && !fog_file.closed?
+          end
           true
         end
 
@@ -285,23 +371,35 @@ module CarrierWave
             end
           else
             # AWS/Google optimized for speed over correctness
-            case @uploader.fog_credentials[:provider]
+            case fog_provider
             when 'AWS'
               # check if some endpoint is set in fog_credentials
               if @uploader.fog_credentials.has_key?(:endpoint)
                 "#{@uploader.fog_credentials[:endpoint]}/#{@uploader.fog_directory}/#{encoded_path}"
               else
                 protocol = @uploader.fog_use_ssl_for_aws ? "https" : "http"
+
+                subdomain_regex = /^(?:[a-z]|\d(?!\d{0,2}(?:\d{1,3}){3}$))(?:[a-z0-9\.]|(?![\-])|\-(?![\.])){1,61}[a-z0-9]$/
+                valid_subdomain = @uploader.fog_directory.to_s =~ subdomain_regex && !(protocol == 'https' && @uploader.fog_directory =~ /\./)
+
                 # if directory is a valid subdomain, use that style for access
-                if @uploader.fog_directory.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\d{1,3}){3}$))(?:[a-z0-9\.]|(?![\-])|\-(?![\.])){1,61}[a-z0-9]$/
-                  "#{protocol}://#{@uploader.fog_directory}.s3.amazonaws.com/#{encoded_path}"
-                else
-                  # directory is not a valid subdomain, so use path style for access
-                  "#{protocol}://s3.amazonaws.com/#{@uploader.fog_directory}/#{encoded_path}"
+                if valid_subdomain
+                  s3_subdomain = @uploader.fog_aws_accelerate ? "s3-accelerate" : "s3"
+                  "#{protocol}://#{@uploader.fog_directory}.#{s3_subdomain}.amazonaws.com/#{encoded_path}"
+                else # directory is not a valid subdomain, so use path style for access
+                  region = @uploader.fog_credentials[:region].to_s
+                  host   = case region
+                           when DEFAULT_S3_REGION, ''
+                             's3.amazonaws.com'
+                           else
+                             "s3.#{region}.amazonaws.com"
+                           end
+                  "#{protocol}://#{host}/#{@uploader.fog_directory}/#{encoded_path}"
                 end
               end
             when 'Google'
-              "https://commondatastorage.googleapis.com/#{@uploader.fog_directory}/#{encoded_path}"
+              # https://cloud.google.com/storage/docs/access-public-data
+              "https://storage.googleapis.com/#{@uploader.fog_directory}/#{encoded_path}"
             else
               # avoid a get by just using local reference
               directory.files.new(:key => path).public_url
@@ -336,9 +434,24 @@ module CarrierWave
         # [NilClass] no file name available
         #
         def filename(options = {})
-          if file_url = url(options)
-            URI.decode(file_url).gsub(/.*\/(.*?$)/, '\1').split('?').first
-          end
+          return unless file_url = url(options)
+          CGI.unescape(file_url.split('?').first).gsub(/.*\/(.*?$)/, '\1')
+        end
+
+        ##
+        # Creates a copy of this file and returns it.
+        #
+        # === Parameters
+        #
+        # [new_path (String)] The path where the file should be copied to.
+        #
+        # === Returns
+        #
+        # @return [CarrierWave::Storage::Fog::File] the location where the file will be stored.
+        #
+        def copy_to(new_path)
+          connection.copy_object(@uploader.fog_directory, file.key, @uploader.fog_directory, new_path, acl_header)
+          CarrierWave::Storage::Fog::File.new(@uploader, @base, new_path)
         end
 
       private
@@ -381,6 +494,33 @@ module CarrierWave
           @file ||= directory.files.head(path)
         end
 
+        def acl_header
+          if fog_provider == 'AWS'
+            { 'x-amz-acl' => @uploader.fog_public ? 'public-read' : 'private' }
+          else
+            {}
+          end
+        end
+
+        def fog_provider
+          @uploader.fog_credentials[:provider].to_s
+        end
+
+        def read_source_file(file_body)
+          return unless ::File.exist?(file_body.path)
+
+          begin
+            file_body = ::File.open(file_body.path) if file_body.closed? # Reopen if it's already closed
+            file_body.read
+          ensure
+            file_body.close
+          end
+        end
+
+        def url_options_supported?(local_file)
+          parameters = local_file.method(:url).parameters
+          parameters.count == 2 && parameters[1].include?(:options)
+        end
       end
 
     end # Fog