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 = Tempfile.new('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 file.read # => "hello world" file.close 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 = Tempfile.new('foo') begin ...do something with file... ensure file.close file.unlink # deletes the temp file end
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.
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 temporally file is removed after the block terminates. The call returns the value of the block.
In any case, all arguments (+*args+) will be treated as ::new.
Tempfile.create('foo', '/home/temp') do |f| ... do something with f ... end
# File lib/tempfile.rb, line 355 def Tempfile.create(basename, *rest) tmpfile = nil Dir::Tmpname.create(basename, *rest) do |tmpname, n, opts| mode = File::RDWR|File::CREAT|File::EXCL perm = 0600 if opts mode |= opts.delete(:mode) || 0 opts[:perm] = perm perm = nil else opts = perm end tmpfile = File.open(tmpname, mode, opts) end if block_given? begin yield tmpfile ensure tmpfile.close if !tmpfile.closed? File.unlink tmpfile end else tmpfile end end
Creates a temporary file with permissions 0600 (= only readable and writable by the owner) and opens it with mode “w+”.
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 = Tempfile.new('hello') file.path # => something like: "/tmp/hello2843-8392-92849382--0" # Use the Array form to enforce an extension in the filename: file = Tempfile.new(['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
When $SAFE > 0 and the given
tmpdir is tainted, it uses
'/tmp' as the temporary directory. Please note that ENV values are tainted by default, and
Dir.tmpdir's return value might come from environment
file = Tempfile.new('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
File.open. These options will be passed to
File.open. This is mostly useful for specifying encoding
Tempfile.new('hello', '/home/aisaka', :encoding => 'ascii-8bit') # You can also omit the 'tmpdir' parameter: Tempfile.new('hello', :encoding => 'ascii-8bit')
If ::new cannot find a unique filename within a limited number of tries, then it will raise an exception.
# File lib/tempfile.rb, line 128 def initialize(basename, *rest) if block_given? warn "Tempfile.new doesn't call the given block." end @data =  @clean_proc = Remover.new(@data) ObjectSpace.define_finalizer(self, @clean_proc) ::Dir::Tmpname.create(basename, *rest) do |tmpname, n, opts| mode = File::RDWR|File::CREAT|File::EXCL perm = 0600 if opts mode |= opts.delete(:mode) || 0 opts[:perm] = perm perm = nil else opts = perm end @data = @tmpfile = File.open(tmpname, mode, opts) @data = @tmpname = tmpname @mode = mode & ~(File::CREAT|File::EXCL) perm or opts.freeze @opts = opts end super(@tmpfile) end
Creates a new Tempfile.
If no block is given, this is a synonym for ::new.
If a block is given, then a Tempfile object will be constructed, and the block is run with said object as argument. The Tempfile object will be automatically closed after the block terminates. The call returns the value of the block.
In any case, all arguments (+*args+) will be passed to ::new.
Tempfile.open('foo', '/home/temp') do |f| ... do something with f ... end # Equivalent: f = Tempfile.open('foo', '/home/temp') begin ... do something with f ... ensure f.close end
# File lib/tempfile.rb, line 319 def open(*args) tempfile = new(*args) if block_given? begin yield(tempfile) ensure tempfile.close end else tempfile end end
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
If you don't explicitly unlink the temporary file, the removal will be delayed until the object is finalized.
# File lib/tempfile.rb, line 180 def close(unlink_now=false) if unlink_now close! else _close end end
Closes and unlinks (deletes) the file. Has the same effect as called
# File lib/tempfile.rb, line 190 def close! _close unlink end
Opens or reopens the file with mode “r+”.
# File lib/tempfile.rb, line 157 def open @tmpfile.close if @tmpfile @tmpfile = File.open(@tmpname, @mode, @opts) @data = @tmpfile __setobj__(@tmpfile) end
Returns the full path name of the temporary file. This will be nil if unlink has been called.
# File lib/tempfile.rb, line 246 def path @tmpname end
Returns the size of the temporary file. As a side effect, the IO buffer is flushed before determining the size.
# File lib/tempfile.rb, line 252 def size if @tmpfile @tmpfile.flush @tmpfile.stat.size elsif @tmpname File.size(@tmpname) else 0 end end