file-temp 1.2.1 → 1.7.0

data/lib/file-temp.rb

@@ -0,0 +1 @@
+require_relative 'file/temp'

data/lib/file/{temp_java.rb → java/temp.rb}

@@ -2,17 +2,14 @@ require 'java'
 import java.lang.System
 
 class File::Temp < File
-  # The version of the file-temp library.
-  VERSION = '1.2.1'
-
   # The temporary directory used on MS Windows or Unix.
   TMPDIR = java.lang.System.getProperties["java.io.tmpdir"]
 
   # The name of the temporary file.
   attr_reader :path
 
-  # Creates a new, anonymous, temporary file in your File::Temp::TMPDIR
-  # directory.
+  # Creates a new, anonymous, temporary file in your system's temporary
+  # directory, or whichever directory you specify.
   #
   # If the +delete+ option is set to true (the default) then the temporary file
   # will be deleted automatically as soon as all references to it are closed.
@@ -30,11 +27,11 @@ class File::Temp < File
   #
   # Example:
   #
-  #    fh = File::Temp.new(true, 'rb_file_temp_XXXXXX') => file
+  #    fh = File::Temp.new(delete: true, template: 'rb_file_temp_XXXXXX')
   #    fh.puts 'hello world'
   #    fh.close
   #
-  def initialize(delete = true, template = 'rb_file_temp_XXXXXX')
+  def initialize(delete: true, template: 'rb_file_temp_XXXXXX', directory: TMPDIR, options: {})
     raise TypeError unless template.is_a?(String)
 
     # Since Java uses a GUID extension to generate a unique file name
@@ -44,26 +41,27 @@ class File::Temp < File
     # For consistency between implementations, convert errors here
     # to Errno::EINVAL.
     begin
-      @file = java.io.File.createTempFile(template, nil)
+      @file = java.io.File.createTempFile(template, nil, java.io.File.new(directory))
     rescue NativeException => err
       raise SystemCallError.new(22), template # 22 is EINVAL
     end
 
     @file.deleteOnExit if delete
+    options[:mode] ||= 'wb+'
 
-    @path = @file.getName
+    path = @file.getName
+    super(path, options)
 
-    super(@path, 'wb+')
+    @path = path unless delete
   end
 
-  # Generates a unique file name.
+  # Generates a unique file name based on your tmpdir, or whichever
+  # directory you specify.
   #
-  def self.temp_name
-    file = java.io.File.createTempFile('rb_file_temp_', nil)
+  def self.temp_name(directory = TMPDIR)
+    file = java.io.File.createTempFile('rb_file_temp_', nil, java.io.File.new(directory))
     file.deleteOnExit
-    name = file.getName
-    file.finalize
-    name
+    directory + file.getName
   end
 
   # Identical to the File#close method except that we also finalize

data/lib/file/temp.rb

@@ -1,5 +1,14 @@
+class File::Temp < File
+  # The version of the file-temp library
+  VERSION = '1.7.0'.freeze
+end
+
 if RUBY_PLATFORM == 'java'
-  require File.join(File.expand_path(File.dirname(__FILE__)), 'temp_java')
+  require_relative 'java/temp'
 else
-  require File.join(File.expand_path(File.dirname(__FILE__)), 'temp_c')
+  if File::ALT_SEPARATOR
+    require_relative 'windows/temp'
+  else
+    require_relative 'unix/temp'
+  end
 end

data/lib/file/unix/temp.rb

@@ -0,0 +1,106 @@
+require 'ffi'
+require 'tmpdir'
+
+class File::Temp < File
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+
+  # :stopdoc:
+
+  private
+
+  attach_function :fclose, [:pointer], :int
+  attach_function :_fileno, :fileno, [:pointer], :int
+  attach_function :strerror, [:int], :string
+  attach_function :tmpfile, [], :pointer
+  attach_function :tmpnam, [:pointer], :string
+  attach_function :mktemp, [:pointer], :string
+
+  private_class_method :mktemp, :strerror, :tmpfile
+  private_class_method :tmpnam, :fclose, :_fileno
+
+  public
+
+  # :startdoc:
+
+  # The temporary directory used on MS Windows or Unix by default.
+  TMPDIR = ENV['TEMP'] || ENV['TMP'] || ENV['TMPDIR'] || Dir.tmpdir
+
+  # The name of the temporary file. Set to nil if the +delete+ option to the
+  # constructor is true.
+  attr_reader :path
+
+  # Creates a new, anonymous, temporary file in your tmpdir, or whichever
+  # directory you specifiy.
+  #
+  # If the +delete+ option is set to true (the default) then the temporary file
+  # will be deleted automatically as soon as all references to it are closed.
+  # Otherwise, the file will live on in your tmpdir path.
+  #
+  # If the +delete+ option is set to false, then the file is not deleted. In
+  # addition, you can supply a string +template+ that the system replaces with
+  # a unique filename. This template should end with 3 to 6 'X' characters.
+  # The default template is 'rb_file_temp_XXXXXX'. In this case the temporary
+  # file lives in the directory where it was created.
+  #
+  # The +template+ argument is ignored if the +delete+ argument is true.
+  #
+  # Example:
+  #
+  #    fh = File::Temp.new(delete: true, template: 'rb_file_temp_XXXXXX') => file
+  #    fh.puts 'hello world'
+  #    fh.close
+  #
+  def initialize(delete: true, template: 'rb_file_temp_XXXXXX', directory: TMPDIR, options: {})
+    @fptr = nil
+
+    if delete
+      @fptr = tmpfile()
+      raise SystemCallError.new('tmpfile', FFI.errno) if @fptr.null?
+      fd = _fileno(@fptr)
+    else
+      begin
+        omask = File.umask(077)
+        ptr = FFI::MemoryPointer.from_string(template)
+        str = mktemp(ptr)
+
+        if str.nil? || str.empty?
+          raise SystemCallError.new('mktemp', FFI.errno)
+        end
+
+        @path = File.join(directory, ptr.read_string)
+      ensure
+        File.umask(omask)
+      end
+    end
+
+    options[:mode] ||= 'wb+'
+
+    if delete
+      super(fd, options)
+    else
+      super(@path, options)
+    end
+  end
+
+  # The close method was overridden to ensure the internal file pointer that we
+  # potentially created in the constructor is closed. It is otherwise identical
+  # to the File#close method.
+  #--
+  # This is probably unnecessary since Ruby will close the fd, and in reality
+  # the fclose function probably fails with an Errno::EBADF. Consequently
+  # I will let it silently fail as a no-op.
+  #
+  def close
+    super
+    fclose(@fptr) if @fptr && !@fptr.null?
+  end
+
+  # Generates a unique file name.
+  #
+  # Note that a file is not actually generated on the filesystem.
+  #
+  def self.temp_name
+    tmpnam(nil) << '.tmp'
+  end
+end

data/lib/file/windows/temp.rb

@@ -0,0 +1,217 @@
+require 'ffi'
+require 'tmpdir'
+
+class File::Temp < File
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+
+  # :stopdoc:
+
+  private
+
+  attach_function :_close, [:int], :int
+  attach_function :fclose, [:pointer], :int
+  attach_function :_fdopen, [:int, :string], :pointer
+  attach_function :_fileno, [:pointer], :int
+  attach_function :_get_errno, [:pointer], :int
+  attach_function :_open, [:string, :int, :int], :int
+  attach_function :_open_osfhandle, [:long, :int], :int
+  attach_function :tmpnam_s, [:pointer, :size_t], :int
+  attach_function :mktemp_s, :_mktemp_s, [:pointer, :size_t], :int
+
+  private_class_method :_close, :fclose, :_fdopen, :_fileno, :_get_errno
+  private_class_method :_open, :_open_osfhandle, :mktemp_s, :tmpnam_s
+
+  ffi_lib :kernel32
+
+  attach_function :CloseHandle, [:long], :bool
+  attach_function :CreateFileW, [:buffer_in, :ulong, :ulong, :pointer, :ulong, :ulong, :ulong], :long
+  attach_function :DeleteFileW, [:string], :bool
+  attach_function :GetTempPathW, [:ulong, :buffer_out], :ulong
+  attach_function :GetTempFileNameW, [:buffer_in, :string, :uint, :buffer_out], :uint
+
+  private_class_method :_close, :_fdopen, :_open, :_open_osfhandle
+  private_class_method :CloseHandle, :CreateFileW, :DeleteFileW
+  private_class_method :GetTempPathW, :GetTempFileNameW
+
+  S_IWRITE      = 128
+  S_IREAD       = 256
+  BINARY        = 0x8000
+  SHORT_LIVED   = 0x1000
+  GENERIC_READ  = 0x80000000
+  GENERIC_WRITE = 0x40000000
+  CREATE_ALWAYS = 2
+
+  FORMAT_MESSAGE_FROM_SYSTEM    = 0x00001000
+  FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x00002000
+
+  FILE_ATTRIBUTE_NORMAL     = 0x00000080
+  FILE_FLAG_DELETE_ON_CLOSE = 0x04000000
+  INVALID_HANDLE_VALUE      = -1
+
+  public
+
+  # :startdoc:
+
+  # The temporary directory used on MS Windows or Unix by default.
+  TMPDIR = ENV['TEMP'] || ENV['TMP'] || ENV['USERPROFILE'] || Dir.tmpdir
+
+  # The name of the temporary file. Set to nil if the +delete+ option to the
+  # constructor is true.
+  attr_reader :path
+
+  # Creates a new, anonymous, temporary file in your File::Temp::TMPDIR
+  # directory, or whichever directory you specify.
+  #
+  # If the +delete+ option is set to true (the default) then the temporary file
+  # will be deleted automatically as soon as all references to it are closed.
+  # Otherwise, the file will live on in your File::Temp::TMPDIR path.
+  #
+  # If the +delete+ option is set to false, then the file is not deleted. In
+  # addition, you can supply a string +template+ that the system replaces with
+  # a unique filename. This template should end with 3 to 6 'X' characters.
+  # The default template is 'rb_file_temp_XXXXXX'. In this case the temporary
+  # file lives in the directory where it was created.
+  #
+  # The +template+ argument is ignored if the +delete+ argument is true.
+  #
+  # Example:
+  #
+  #    fh = File::Temp.new(delete: true, template: 'rb_file_temp_XXXXXX')
+  #    fh.puts 'hello world'
+  #    fh.close
+  #
+  def initialize(delete: true, template: 'rb_file_temp_XXXXXX', directory: TMPDIR, options: {})
+    @fptr = nil
+
+    if delete
+      @fptr = tmpfile()
+      fd = _fileno(@fptr)
+    else
+      begin
+        omask = File.umask(077)
+        ptr = FFI::MemoryPointer.from_string(template)
+        errno = mktemp_s(ptr, ptr.size)
+
+        raise SystemCallError.new('mktemp_s', errno) if errno != 0
+
+        @path = File.join(directory, ptr.read_string)
+        @path.tr!(File::SEPARATOR, File::ALT_SEPARATOR)
+      ensure
+        File.umask(omask)
+      end
+    end
+
+    options[:mode] ||= 'wb+'
+
+    if delete
+      super(fd, options)
+    else
+      super(@path, options)
+    end
+  end
+
+  # The close method was overridden to ensure the internal file pointer we
+  # created in the constructor is closed. It is otherwise identical to the
+  # File#close method.
+  #
+  def close
+    super
+    fclose(@fptr) if @fptr
+  end
+
+  # Generates a unique file name based on your default temporary directory,
+  # or whichever directory you specify.
+  #
+  # Note that a file is not actually generated on the filesystem.
+  #--
+  # NOTE: One quirk of the Windows function is that, after the first call, it
+  # adds a file extension of sequential numbers in base 32, e.g. .1-.1vvvvvu.
+  #
+  def self.temp_name(directory: TMPDIR)
+    ptr = FFI::MemoryPointer.new(:char, 1024)
+    errno = tmpnam_s(ptr, ptr.size)
+
+    raise SystemCallError.new('tmpnam_s', errno) if errno != 0
+
+    directory + ptr.read_string + 'tmp'
+  end
+
+  private
+
+  # For those times when we want the posix errno rather than a formatted string.
+  # This is necessary because FFI.errno appears to be using GetLastError() which
+  # does not always match what _get_errno() returns.
+  #
+  def get_posix_errno
+    ptr = FFI::MemoryPointer.new(:int)
+    _get_errno(ptr)
+    ptr.read_int
+  end
+
+  # Simple wrapper around the GetTempPath function.
+  #
+  def get_temp_path
+    buf = 0.chr * 1024
+    buf.encode!("UTF-16LE")
+
+    if GetTempPathW(buf.size, buf) == 0
+      raise SystemCallError, FFI.errno, 'GetTempPathW'
+    end
+
+    buf.strip.chop # remove trailing slash
+  end
+
+  # The version of tmpfile() implemented by Microsoft is unacceptable.
+  # It attempts to write to C:\ (root) instead of a temporary directory.
+  # This is not only bad behavior, it won't work on Windows 7 and later
+  # without admin rights due to security restrictions.
+  #
+  # This is a custom implementation based on some code from the Cairo
+  # project.
+  #
+  def tmpfile
+    file_name = get_temp_path()
+    buf = 0.chr * 1024
+    buf.encode!("UTF-16LE")
+
+    if GetTempFileNameW(file_name, 'rb_', 0, buf) == 0
+      raise SystemCallError, FFI.errno, 'GetTempFileNameW'
+    end
+
+    file_name = buf.strip
+
+    handle = CreateFileW(
+      file_name,
+      GENERIC_READ | GENERIC_WRITE,
+      0,
+      nil,
+      CREATE_ALWAYS,
+      FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
+      0
+    )
+
+    if handle == INVALID_HANDLE_VALUE
+      error = FFI.errno
+      DeleteFileW(file_name)
+      raise SystemCallError.new('CreateFileW', error)
+    end
+
+    fd = _open_osfhandle(handle, 0)
+
+    if fd < 0
+      CloseHandle(handle)
+      raise SystemCallError, get_posix_errno, '_open_osfhandle'
+    end
+
+    fp = _fdopen(fd, 'w+b')
+
+    if fp.nil?
+      _close(fd)
+      CloseHandle(handle)
+      raise SystemCallError, get_posix_errno, 'fdopen'
+    end
+
+    fp
+  end
+end

data/spec/file_temp_spec.rb

@@ -0,0 +1,159 @@
+######################################################################
+# file_temp_spec.rb
+#
+# Test suite for the file-temp library. These tests should be run
+# via the 'rake spec' task.
+######################################################################
+require 'rspec'
+require 'file/temp'
+
+RSpec.describe File::Temp do
+  let(:windows) { File::ALT_SEPARATOR }
+  let(:osx) { RbConfig::CONFIG['host_os'] =~ /darwin/i }
+
+  before do
+    @dir = File::Temp::TMPDIR
+    @template = 'file-temp-test-XXXXX'
+    @fh = nil
+
+    # Because Dir[] doesn't work right with backslashes
+    @dir = @dir.tr("\\", "/") if windows
+  end
+
+  context "constants" do
+    example "library version is set to expected value" do
+      expect( File::Temp::VERSION).to eq('1.7.0')
+      expect(File::Temp::VERSION).to be_frozen
+    end
+
+    example "TMPDIR constant is defined" do
+      expect(File::Temp::TMPDIR).to be_kind_of(String)
+      expect(File::Temp::TMPDIR.size).to be > 0
+    end
+  end
+
+  context "threads" do
+    example "library works as expected with multiple threads" do
+      threads = []
+      expect{ 100.times{ threads << Thread.new{ File::Temp.new }}}.not_to raise_error
+      expect{ threads.each{ |t| t.join }.not_to raise_error }
+    end
+  end
+
+  context "constructor" do
+    example "constructor works as expected with default auto delete option" do
+      expect{
+        @fh = File::Temp.new
+        @fh.print "hello"
+        @fh.close
+      }.not_to raise_error
+    end
+
+    example "constructor works as expected with false auto delete option" do
+      expect{
+        @fh = File::Temp.new(:delete => false)
+        @fh.print "hello"
+        @fh.close
+      }.not_to raise_error
+    end
+
+    example "constructor accepts and uses an optional template as expected" do
+      expect{ File::Temp.new(:delete => false, :template => 'temp_foo_XXXXXX').close }.not_to raise_error
+      expect(Dir["#{@dir}/temp_foo*"].length).to be >= 1
+    end
+
+    example "constructor with false auto delete and block works as expected" do
+      expect{
+        File::Temp.open(:delete => false, :template => 'temp_foo_XXXXXX'){ |fh| fh.puts "hello" }
+      }.not_to raise_error
+      expect(Dir["#{@dir}/temp_foo*"].length).to be >= 1
+    end
+
+    example "constructor accepts a maximum of three arguments" do
+      expect{
+        @fh = File::Temp.new(
+          :delete     => true,
+          :template   => 'temp_bar_XXXXX',
+          :directory  => Dir.pwd,
+          :bogus      => 1
+        )
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "template" do
+    example "template argument must be a string" do
+      expect{ @fh = File::Temp.new(:delete => false, :template => 1) }.to raise_error(TypeError)
+    end
+
+    example "an error is raised if a custom template is invalid" do
+      skip "skipped on OSX" if osx
+      expect{ File::Temp.new(:delete => false, :template => 'xx') }.to raise_error(Errno::EINVAL)
+    end
+  end
+
+  context "temp_name" do
+    example "temp_name basic functionality" do
+      expect(File::Temp).to respond_to(:temp_name)
+      expect{ File::Temp.temp_name }.not_to raise_error
+      expect(File::Temp.temp_name).to be_kind_of(String)
+    end
+
+    example "temp_name returns expected value" do
+      if windows
+        expect( File.extname(File::Temp.temp_name)).to match(/^.*?\d*?tmp/)
+      else
+        expect( File.extname(File::Temp.temp_name)).to eq('.tmp')
+      end
+    end
+  end
+
+  context "path" do
+    example "temp path basic functionality" do
+      @fh = File::Temp.new
+      expect(@fh).to respond_to(:path)
+    end
+
+    example "temp path is nil if delete option is true" do
+      @fh = File::Temp.new
+      expect(@fh.path).to be_nil
+    end
+
+    example "temp path is not nil if delete option is false" do
+      @fh = File::Temp.new(delete: false)
+      expect(@fh.path).not_to be_nil
+    end
+  end
+
+  context "ffi" do
+    example "ffi functions are private" do
+      methods = File::Temp.methods(false).map(&:to_s)
+      expect(methods).not_to include('_fileno')
+      expect(methods).not_to include('mkstemp')
+      expect(methods).not_to include('_umask')
+      expect(methods).not_to include('fclose')
+      expect(methods).not_to include('strerror')
+      expect(methods).not_to include('tmpnam')
+      expect(methods).not_to include('CloseHandle')
+      expect(methods).not_to include('CreateFileA')
+      expect(methods).not_to include('DeleteFileA')
+      expect(methods).not_to include('GetTempPathA')
+      expect(methods).not_to include('GetTempFileNameA')
+    end
+  end
+
+  after do
+    @dir = nil
+    @template = nil
+    @fh.close if @fh && !@fh.closed?
+    @fh = nil
+
+    Dir["temp_*"].each{ |f| File.delete(f) }
+    Dir["rb_file_temp_*"].each{ |f| File.delete(f) }
+
+    Dir.chdir(File::Temp::TMPDIR) do
+      Dir["temp_*"].each{ |f| File.delete(f) }
+      Dir["rb_file_temp_*"].each{ |f| File.delete(f) }
+    end
+  end
+end