class Tempfile

A utility class for managing temporary files. When you create a Tempfile object, it will create a temporary file with a unique filename. A Tempfile objects behaves just like a File object, and you can perform all the usual file operations on it: reading data, writing data, changing its permissions, etc. So although this class does not explicitly document all instance methods supported by File, you can in fact call any File instance method on a Tempfile object.


require 'tempfile'

file ='foo')
file.path      # => A unique filename in the OS's temp directory,
               #    e.g.: "/tmp/foo.24722.0"
               #    This filename contains 'foo' in its basename.
file.write("hello world")
file.rewind      # => "hello world"
file.unlink    # deletes the temp file

Good practices

Explicit close

When a Tempfile object is garbage collected, or when the Ruby interpreter exits, its associated temporary file is automatically deleted. This means that’s it’s unnecessary to explicitly delete a Tempfile after use, though it’s good practice to do so: not explicitly deleting unused Tempfiles can potentially leave behind large amounts of tempfiles on the filesystem until they’re garbage collected. The existence of these temp files can make it harder to determine a new Tempfile filename.

Therefore, one should always call unlink or close in an ensure block, like this:

file ='foo')
   # something with file...
   file.unlink   # deletes the temp file

Tempfile.create { … } exists for this purpose and is more convenient to use. Note that Tempfile.create returns a File instance instead of a Tempfile, which also avoids the overhead and complications of delegation.'foo') do |file|
   # something with file...

Unlink after creation

On POSIX systems, it’s possible to unlink a file right after creating it, and before closing it. This removes the filesystem entry without closing the file handle, so it ensures that only the processes that already had the file handle open can access the file’s contents. It’s strongly recommended that you do this if you do not want any other processes to be able to read from or write to the Tempfile, and you do not need to know the Tempfile’s filename either.

For example, a practical use case for unlink-after-creation would be this: you need a large byte buffer that’s too large to comfortably fit in RAM, e.g. when you’re writing a web server and you want to buffer the client’s file upload data.

Please refer to unlink for more information and a code example.

Minor notes

Tempfile’s filename picking method is both thread-safe and inter-process-safe: it guarantees that no other threads or processes will pick the same filename.

Tempfile itself however may not be entirely thread-safe. If you access the same Tempfile object from multiple threads then you should protect it with a mutex.

Public Class Methods

create(basename="", tmpdir=nil, mode: 0, **options) { |tmpfile| ... } click to toggle source

Creates a temporary file as a usual File object (not a Tempfile). It does not use finalizer and delegation, which makes it more efficient and reliable.

If no block is given, this is similar to except creating File instead of Tempfile. In that case, the created file is not removed automatically. You should use File.unlink to remove it.

If a block is given, then a File object will be constructed, and the block is invoked with the object as the argument. The File object will be automatically closed and the temporary file is removed after the block terminates, releasing all resources that the block created. The call returns the value of the block.

In any case, all arguments (basename, tmpdir, mode, and **options) will be treated the same as for

Tempfile.create('foo', '/home/temp') do |f|
   # ... do something with f ...
# File tempfile.rb, line 349
def Tempfile.create(basename="", tmpdir=nil, mode: 0, **options)
  tmpfile = nil
  Dir::Tmpname.create(basename, tmpdir, **options) do |tmpname, n, opts|
    mode |= File::RDWR|File::CREAT|File::EXCL
    opts[:perm] = 0600
    tmpfile =, mode, **opts)
  if block_given?
      yield tmpfile
      unless tmpfile.closed?
        if File.identical?(tmpfile, tmpfile.path)
          unlinked = File.unlink tmpfile.path rescue nil
      unless unlinked
          File.unlink tmpfile.path
        rescue Errno::ENOENT
new(basename="", tmpdir=nil, mode: 0, **options) click to toggle source

Creates a temporary file with permissions 0600 (= only readable and writable by the owner) and opens it with mode “w+”.

It is recommended to use Tempfile.create { … } instead when possible, because that method avoids the cost of delegation and does not rely on a finalizer to close and unlink the file, which is unreliable.

The basename parameter is used to determine the name of the temporary file. You can either pass a String or an Array with 2 String elements. In the former form, the temporary file’s base name will begin with the given string. In the latter form, the temporary file’s base name will begin with the array’s first element, and end with the second element. For example:

file ='hello')
file.path  # => something like: "/tmp/hello2843-8392-92849382--0"

# Use the Array form to enforce an extension in the filename:
file =['hello', '.jpg'])
file.path  # => something like: "/tmp/hello2843-8392-92849382--0.jpg"

The temporary file will be placed in the directory as specified by the tmpdir parameter. By default, this is Dir.tmpdir.

file ='hello', '/home/aisaka')
file.path  # => something like: "/home/aisaka/hello2843-8392-92849382--0"

You can also pass an options hash. Under the hood, Tempfile creates the temporary file using These options will be passed to This is mostly useful for specifying encoding options, e.g.:'hello', '/home/aisaka', encoding: 'ascii-8bit')

# You can also omit the 'tmpdir' parameter:'hello', encoding: 'ascii-8bit')

Note: mode keyword argument, as accepted by Tempfile, can only be numeric, combination of the modes defined in File::Constants.


If cannot find a unique filename within a limited number of tries, then it will raise an exception.

Calls superclass method
# File tempfile.rb, line 134
def initialize(basename="", tmpdir=nil, mode: 0, **options)
  warn " doesn't call the given block.", uplevel: 1 if block_given?

  @unlinked = false
  @mode = mode|File::RDWR|File::CREAT|File::EXCL
  ::Dir::Tmpname.create(basename, tmpdir, **options) do |tmpname, n, opts|
    opts[:perm] = 0600
    @tmpfile =, @mode, **opts)
    @opts = opts.freeze

open(*args, **kw) { |tempfile| ... } click to toggle source

Creates a new Tempfile.

This method is not recommended and exists mostly for backward compatibility. Please use Tempfile.create instead, which avoids the cost of delegation, does not rely on a finalizer, and also unlinks the file when given a block. is still appropriate if you need the Tempfile to be unlinked by a finalizer and you cannot explicitly know where in the program the Tempfile can be unlinked safely.

If no block is given, this is a synonym for

If a block is given, then a Tempfile object will be constructed, and the block is run with the Tempfile object as argument. The Tempfile object will be automatically closed after the block terminates. However, the file will not be unlinked and needs to be manually unlinked with Tempfile#close! or Tempfile#unlink. The finalizer will try to unlink but should not be relied upon as it can keep the file on the disk much longer than intended. For instance, on CRuby, finalizers can be delayed due to conservative stack scanning and references left in unused memory.

The call returns the value of the block.

In any case, all arguments (*args) will be passed to'foo', '/home/temp') do |f|
   # ... do something with f ...

# Equivalent:
f ='foo', '/home/temp')
   # ... do something with f ...
# File tempfile.rb, line 312
def open(*args, **kw)
  tempfile = new(*args, **kw)

  if block_given?

Public Instance Methods

close(unlink_now=false) click to toggle source

Closes the file. If unlink_now is true, then the file will be unlinked (deleted) after closing. Of course, you can choose to later call unlink if you do not unlink it now.

If you don’t explicitly unlink the temporary file, the removal will be delayed until the object is finalized.

# File tempfile.rb, line 168
def close(unlink_now=false)
  unlink if unlink_now
close!() click to toggle source

Closes and unlinks (deletes) the file. Has the same effect as called close(true).

# File tempfile.rb, line 175
def close!
Alias for: unlink
Alias for: size
open() click to toggle source

Opens or reopens the file with mode “r+”.

# File tempfile.rb, line 150
def open
  mode = @mode & ~(File::CREAT|File::EXCL)
  @tmpfile =, mode, **@opts)
path() click to toggle source

Returns the full path name of the temporary file. This will be nil if unlink has been called.

# File tempfile.rb, line 228
def path
  @unlinked ? nil : @tmpfile.path
size() click to toggle source

Returns the size of the temporary file. As a side effect, the IO buffer is flushed before determining the size.

# File tempfile.rb, line 234
def size
  if !@tmpfile.closed?
    @tmpfile.size # File#size calls rb_io_flush_raw()
Also aliased as: length