file-temp 1.2.0 → 1.2.1

data/lib/file/temp_c.rb

@@ -0,0 +1,254 @@
+require 'ffi'
+require 'tmpdir'
+
+class File::Temp < File
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+
+  # :stopdoc:
+
+  private
+
+  if File::ALT_SEPARATOR
+    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, :_fdopen, :_get_errno, :_open
+    private_class_method :_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
+  else
+    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, :tmpnam
+  end
+
+  private_class_method :fclose, :_fileno
+
+  public
+
+  # :startdoc:
+
+  # The version of the file-temp library.
+  VERSION = '1.2.1'
+
+  # The temporary directory used on MS Windows or Unix.
+  if File::ALT_SEPARATOR
+    TMPDIR = ENV['TEMP'] || ENV['TMP'] || ENV['USERPROFILE'] || Dir.tmpdir
+  else
+    TMPDIR = ENV['TEMP'] || ENV['TMP'] || ENV['TMPDIR'] || Dir.tmpdir
+  end
+
+  # 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
+  #
+  # 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(true, 'rb_file_temp_XXXXXX') => file
+  #    fh.puts 'hello world'
+  #    fh.close
+  #
+  def initialize(delete = true, template = 'rb_file_temp_XXXXXX')
+    @fptr = nil
+
+    if delete
+      @fptr = tmpfile()
+      fd = _fileno(@fptr)
+    else
+      begin
+        omask = File.umask(077)
+
+        ptr = FFI::MemoryPointer.from_string(template)
+
+        if File::ALT_SEPARATOR
+          errno = mktemp_s(ptr, ptr.size)
+
+          raise SystemCallError.new('mktemp_s', errno) if errno != 0
+        else
+          str = mktemp(ptr)
+
+          if str.nil? || str.empty?
+            raise SystemCallError.new('mktemp', FFI.errno)
+          end
+        end
+
+        @path = File.join(TMPDIR, ptr.read_string)
+        @path.tr!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+      ensure
+        File.umask(omask)
+      end
+    end
+
+    if delete
+      super(fd, 'wb+')
+    else
+      super(@path, 'wb+')
+    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.
+  #
+  # 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
+    if File::ALT_SEPARATOR
+      ptr = FFI::MemoryPointer.new(:char, 1024)
+      errno = tmpnam_s(ptr, ptr.size)
+
+      raise SystemCallError.new('tmpnam_s', errno) if errno != 0
+
+      TMPDIR + ptr.read_string + 'tmp'
+    else
+      tmpnam(nil) << '.tmp'
+    end
+  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
+    if File::ALT_SEPARATOR
+      ptr = FFI::MemoryPointer.new(:int)
+      _get_errno(ptr)
+      ptr.read_int
+    else
+      FFI.errno
+    end
+  end
+
+  if File::ALT_SEPARATOR
+    # 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
+end

data/lib/file/temp_java.rb

@@ -0,0 +1,76 @@
+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.
+  #
+  # 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.
+  #
+  # Note that when using JRuby the template naming is not as strict, and the
+  # trailing 'X' characters are simply replaced with the GUID that Java
+  # generates for unique file names.
+  #
+  # Example:
+  #
+  #    fh = File::Temp.new(true, 'rb_file_temp_XXXXXX') => file
+  #    fh.puts 'hello world'
+  #    fh.close
+  #
+  def initialize(delete = true, template = 'rb_file_temp_XXXXXX')
+    raise TypeError unless template.is_a?(String)
+
+    # Since Java uses a GUID extension to generate a unique file name
+    # we'll simply chop off the 'X' characters and let Java do the rest.
+    template = template.sub(/_X{1,6}/, '_')
+
+    # For consistency between implementations, convert errors here
+    # to Errno::EINVAL.
+    begin
+      @file = java.io.File.createTempFile(template, nil)
+    rescue NativeException => err
+      raise SystemCallError.new(22), template # 22 is EINVAL
+    end
+
+    @file.deleteOnExit if delete
+
+    @path = @file.getName
+
+    super(@path, 'wb+')
+  end
+
+  # Generates a unique file name.
+  #
+  def self.temp_name
+    file = java.io.File.createTempFile('rb_file_temp_', nil)
+    file.deleteOnExit
+    name = file.getName
+    file.finalize
+    name
+  end
+
+  # Identical to the File#close method except that we also finalize
+  # the underlying Java File object.
+  #
+  def close
+    super
+    @file.finalize
+  end
+end

data/test/test_file_temp.rb

@@ -1,120 +1,135 @@
-######################################################################
-# test_file_temp.rb
-#
-# Test suite for the file-temp library. These tests should be run
-# via the 'rake test' task.
-######################################################################
-require 'rubygems'
-require 'test-unit'
-require 'file/temp'
-
-class TC_File_Temp < Test::Unit::TestCase
-  WINDOWS = File::ALT_SEPARATOR
-
-  def setup
-    @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
-
-  def test_file_temp_version
-    assert_equal('1.2.0', File::Temp::VERSION)
-  end
-
-  def test_file_temp_threaded
-    threads = []
-    assert_nothing_raised{ 100.times{ threads << Thread.new{ File::Temp.new }}}
-    assert_nothing_raised{ threads.join }
-  end
-
-  def test_file_temp_tmpdir
-    assert_not_nil(File::Temp::TMPDIR)
-    assert_kind_of(String, File::Temp::TMPDIR)
-  end
-
-  def test_file_temp_auto_delete
-    assert_nothing_raised{ @fh = File::Temp.new }
-    assert_nothing_raised{ @fh.print "hello" }
-    assert_nothing_raised{ @fh.close }
-  end
-
-  def test_file_temp_no_delete
-    assert_nothing_raised{ @fh = File::Temp.new(false) }
-    assert_nothing_raised{ @fh.print "hello" }
-    assert_nothing_raised{ @fh.close }
-    assert_true(Dir["#{@dir}/rb_file_temp*"].length == 1)
-  end
-
-  def test_file_temp_no_delete_with_template
-    assert_nothing_raised{ File::Temp.new(false, 'temp_foo_XXXXXX').close }
-    assert_true(Dir["#{@dir}/temp_foo*"].length >= 1)
-  end
-
-  def test_file_temp_no_delete_with_block
-    assert_nothing_raised{ File::Temp.open(false, 'temp_foo_XXXXXX'){ |fh| fh.puts "hello" } }
-    assert_true(Dir["#{@dir}/temp_foo*"].length >= 1)
-  end
-
-  def test_file_temp_expected_errors
-    assert_raise(TypeError, ArgumentError){ @fh = File::Temp.new(false, 1) }
-    assert_raise(ArgumentError){ @fh = File::Temp.new(true, 'temp_bar_XXXXX', 1) }
-  end
-
-  def test_file_temp_name_basic_functionality
-    assert_respond_to(File::Temp, :temp_name)
-    assert_nothing_raised{ File::Temp.temp_name }
-    assert_kind_of(String, File::Temp.temp_name)
-  end
-
-  def test_file_temp_name
-    assert_equal('.tmp', File.extname(File::Temp.temp_name))
-  end
-
-  def test_file_temp_path_basic_functionality
-    @fh = File::Temp.new
-    assert_respond_to(@fh, :path)
-  end
-
-  def test_file_temp_path_is_nil_if_delete_option_is_true
-    @fh = File::Temp.new
-    assert_nil(@fh.path)
-  end
-
-  def test_file_temp_path_is_not_nil_if_delete_option_is_false
-    @fh = File::Temp.new(false)
-    assert_not_nil(@fh.path)
-  end
-
-  def test_ffi_functions_are_private
-    methods = File::Temp.methods(false).map{ |e| e.to_s }
-    assert_false(methods.include?('_fileno'))
-    assert_false(methods.include?('mkstemp'))
-    assert_false(methods.include?('_umask'))
-    assert_false(methods.include?('fclose'))
-    assert_false(methods.include?('strerror'))
-    assert_false(methods.include?('tmpnam'))
-    assert_false(methods.include?('CloseHandle'))
-    assert_false(methods.include?('CreateFileA'))
-    assert_false(methods.include?('DeleteFileA'))
-    assert_false(methods.include?('GetTempPathA'))
-    assert_false(methods.include?('GetTempFileNameA'))
-  end
-
-  def teardown
-    @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
+######################################################################
+# test_file_temp.rb
+#
+# Test suite for the file-temp library. These tests should be run
+# via the 'rake test' task.
+######################################################################
+require 'rubygems'
+require 'test-unit'
+require 'file/temp'
+
+class TC_File_Temp < Test::Unit::TestCase
+  WINDOWS = File::ALT_SEPARATOR
+
+  def setup
+    @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
+
+  test "library version is set to expected value" do
+    assert_equal('1.2.1', File::Temp::VERSION)
+  end
+
+  # Fails with JRuby, not sure why.
+  test "library works as expected with multiple threads" do
+    threads = []
+    assert_nothing_raised{ 100.times{ threads << Thread.new{ File::Temp.new }}}
+    assert_nothing_raised{ threads.each{ |t| t.join } }
+  end
+
+  test "TMPDIR constant is defined" do
+    assert_not_nil(File::Temp::TMPDIR)
+    assert_kind_of(String, File::Temp::TMPDIR)
+  end
+
+  test "constructor works as expected with default auto delete option" do
+    assert_nothing_raised{
+      @fh = File::Temp.new
+      @fh.print "hello"
+      @fh.close
+    }
+  end
+
+  test "constructor works as expected with false auto delete option" do
+    assert_nothing_raised{
+      @fh = File::Temp.new(false)
+      @fh.print "hello"
+      @fh.close
+    }
+  end
+
+  test "constructor accepts and uses an optional template as expected" do
+    assert_nothing_raised{ File::Temp.new(false, 'temp_foo_XXXXXX').close }
+    assert_true(Dir["#{@dir}/temp_foo*"].length >= 1)
+  end
+
+  test "constructor with false auto delete and block works as expected" do
+    assert_nothing_raised{ File::Temp.open(false, 'temp_foo_XXXXXX'){ |fh| fh.puts "hello" } }
+    assert_true(Dir["#{@dir}/temp_foo*"].length >= 1)
+  end
+
+  test "second argument to constructor must be a string" do
+    assert_raise(TypeError, ArgumentError){ @fh = File::Temp.new(false, 1) }
+  end
+
+  test "an error is raised if a custom template is invalid" do
+    assert_raise(Errno::EINVAL){ File::Temp.new(false, 'xx') }
+  end
+
+  test "constructor accepts a maximum of two arguments" do
+    assert_raise(ArgumentError){ @fh = File::Temp.new(true, 'temp_bar_XXXXX', 1) }
+  end
+
+  test "temp_name basic functionality" do
+    assert_respond_to(File::Temp, :temp_name)
+    assert_nothing_raised{ File::Temp.temp_name }
+    assert_kind_of(String, File::Temp.temp_name)
+  end
+
+  test "temp_name returns expected value" do
+    if File::ALT_SEPARATOR
+      assert_match(/^.*?\d*?tmp/, File.extname(File::Temp.temp_name))
+    else
+      assert_equal('.tmp', File.extname(File::Temp.temp_name))
+    end
+  end
+
+  test "temp path basic functionality" do
+    @fh = File::Temp.new
+    assert_respond_to(@fh, :path)
+  end
+
+  test "temp path is nil if delete option is true" do
+    @fh = File::Temp.new
+    assert_nil(@fh.path)
+  end
+
+  test "temp path is not nil if delete option is false" do
+    @fh = File::Temp.new(false)
+    assert_not_nil(@fh.path)
+  end
+
+  test "ffi functions are private" do
+    methods = File::Temp.methods(false).map{ |e| e.to_s }
+    assert_false(methods.include?('_fileno'))
+    assert_false(methods.include?('mkstemp'))
+    assert_false(methods.include?('_umask'))
+    assert_false(methods.include?('fclose'))
+    assert_false(methods.include?('strerror'))
+    assert_false(methods.include?('tmpnam'))
+    assert_false(methods.include?('CloseHandle'))
+    assert_false(methods.include?('CreateFileA'))
+    assert_false(methods.include?('DeleteFileA'))
+    assert_false(methods.include?('GetTempPathA'))
+    assert_false(methods.include?('GetTempFileNameA'))
+  end
+
+  def teardown
+    @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