better 1.0.0

data/LICENSE

@@ -0,0 +1 @@
+Distributed under the same license as Ruby itself.

data/README.rdoc

@@ -0,0 +1,40 @@
+= Overview
+
+Better is a collection of better replacements Ruby standard libraries. The versions shipped with Ruby have problems, which this library intends to fix. It is my wish that this code will one day find its way back to upstream Ruby.
+
+* Github: http://github.com/FooBarWidget/better/tree/master
+* API documentation: http://better.rubyforge.org/
+
+== Usage
+
+Install with:
+
+  gem install better
+
+All of the libraries in Better are drop-in replacement and have the exact same API as the original, and work on both Ruby 1.8 and 1.9. For example, instead of
+
+  require 'tempfile'
+  Tempfile.new(...)
+
+you just prefix the library filename with 'better/' and the class name with 'Better::':
+
+  require 'better/tempfile'
+  Better::Tempfile.new(...)
+
+Or you can even override the standard version by requiring the library with the 'better/override/' prefix:
+
+  require 'better/override/tempfile'
+  Tempfile  # => now refers to Better::Tempfile instead of ::Tempfile
+
+This last feature should of course be used with care.
+
+Please refer to the individual classes for more documentation.
+
+== Contributing
+
+The Github repository is located at http://github.com/FooBarWidget/better/tree/master.
+Is there a Ruby standard library that you think can be improved? Just fork the repository and start hacking! It doesn't matter whether you want to fix a small bug, want to write unit tests or just want to improve documentation - anything is fine.
+
+You can contact me at:
+
+* Hongli Lai (hongli@phusion.nl)

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'rubygems'
+  require 'hanna/rdoctask'
+rescue LoadError
+  STDERR.puts "*** Warning: you do not have the Hanna rdoc template installed. The rdoc will look better if you do. You should type:"
+  STDERR.puts "  sudo gem sources -a http://gems.github.com"
+  STDERR.puts "  sudo gem install mislav-hanna"
+  STDERR.puts
+  require 'rake/rdoctask'
+end
+require 'rake/testtask'
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.title = "Better: API documentation"
+  rd.rdoc_files.include("README.rdoc", "LICENSE", "lib/**/*.rb")
+  rd.rdoc_dir = "doc"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+desc "Upload documentation to Rubyforge"
+task :upload => :rdoc do
+	sh "scp -Cr doc/* rubyforge.org:/var/www/gforge-projects/better/"
+end

data/better.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = "better"
+  s.version = "1.0.0"
+  s.summary = "Collection of better replacements for Ruby standard libraries"
+  s.email = "hongli@phusion.nl"
+  s.homepage = "http://better.rubyforge.org/"
+  s.description = "Collection of better replacements for Ruby standard libraries."
+  s.has_rdoc = true
+  s.rubyforge_project = "better"
+  s.authors = ["Hongli Lai"]
+  
+  s.files = [
+      "README.rdoc", "LICENSE", "better.gemspec", "Rakefile",
+      "lib/better/tempfile.rb",
+      "lib/better/override/tempfile.rb",
+      "test/test_helper.rb",
+      "test/example_helper.rb",
+      "test/tempfile_test.rb",
+      "test/tempfile_explicit_close_and_unlink_example.rb",
+      "test/tempfile_explicit_unlink_example.rb",
+      "test/tempfile_unlink_on_exit_example.rb"
+  ]
+end

data/lib/better/override/tempfile.rb

@@ -0,0 +1,3 @@
+require 'better/tempfile'
+Object.send(:remove_const, :Tempfile) if defined?(Tempfile)
+::Tempfile = Better::Tempfile

data/lib/better/tempfile.rb

@@ -0,0 +1,391 @@
+#
+# tempfile - manipulates temporary files
+#
+# $Id$
+#
+
+require 'delegate'
+require 'tmpdir'
+require 'thread'
+
+module Better
+
+# 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.
+#
+# == Comparison to Ruby's bundled version
+#
+# * Much better documentation.
+# * Is unit tested.
+# * Ruby 1.8's version can generate "weird" path names that can confuse certain
+#   command line tools such as Curl. Better::Tempfile is based on Ruby 1.9's
+#   version and generates saner filenames.
+# * Ruby 1.8's version has a bug which makes unlink-before-close (as described
+#   below) unusable: it raises an an exception when #close is called if the
+#   tempfile was unlinked before.
+# * Ruby 1.9.1's version closes the file when #unlink is called. This makes
+#   unlink-before-close unusable.
+# * Ruby's bundled version deletes the temporary file in its finalizer, even
+#   when #unlink was called before. As a result it may potentially delete other
+#   Ruby processes' temp files when it's not supposed to.
+#
+# Better::Tempfile is based on Ruby 1.9.2's version (SVN 24594).
+#
+# == Synopsis
+#
+#   require 'better/tempfile'
+#   
+#   file = Better::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 existance 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 = Better::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.
+class Tempfile < DelegateClass(File)
+  MAX_TRIES = 10  # :nodoc:
+  @@live_tempfiles = []
+  @@lock = Mutex.new
+  
+  class CreationError < StandardError # :nodoc:
+  end
+  
+  class << self
+    # Creates a new Tempfile.
+    #
+    # If no block is given, this is a synonym for Tempfile.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
+    # oject 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 Tempfile.new.
+    #
+    #   Better::Tempfile.open('foo', '/home/temp') do |f|
+    #      ... do something with f ...
+    #   end
+    #   
+    #   # Equivalent:
+    #   f = Better::Tempfile.open('foo', '/home/temp')
+    #   begin
+    #      ... do something with f ...
+    #   ensure
+    #      f.close
+    #   end
+    def open(*args)
+      tempfile = new(*args)
+
+      if block_given?
+        begin
+          yield(tempfile)
+        ensure
+          tempfile.close
+        end
+      else
+        tempfile
+      end
+    end
+    
+    def create_finalizer_callback(info) # :nodoc:
+      original_pid = $$
+      Proc.new do
+        # If we forked, then don't cleanup the temp files created by
+        # the parent process.
+        if original_pid == $$
+          path, tmpfile, live_tempfiles = *info
+          tmpfile.close if tmpfile
+          File.unlink(path) if path && File.exist?(path)
+          live_tempfiles.delete(path) if live_tempfiles
+        end
+      end
+    end
+    
+    def make_directory(dir) # :nodoc:
+      Dir.mkdir(dir)
+    end
+  end
+  
+  # call-seq:
+  #    new(basename, [tmpdir = Dir.tmpdir], [options])
+  #
+  # Creates a temporary file with permissions 0600 (= only readable and
+  # writable by the owner) and opens it with mode "w+".
+  #
+  # 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 = Better::Tempfile.new('hello')
+  #   file.path  # => something like: "/tmp/foo2843-8392-92849382--0"
+  #   
+  #   # Use the Array form to enforce an extension in the filename:
+  #   file = Better::Tempfile.new(['hello', '.jpg'])
+  #   file.path  # => something like: "/tmp/foo2843-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+ (see
+  # 'tmpdir.rb' in the Ruby standard library.)
+  # 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 variables (e.g. <tt>$TMPDIR</tt>).
+  #
+  #   file = Better::Tempfile.new('hello', '/home/aisaka')
+  #   file.path  # => something like: "/home/aisaka/foo2843-8392-92849382--0"
+  #
+  # You can also pass an options hash. Under the hood, Better::Tempfile creates
+  # the temporary file using +File.open+. These options will be passed to
+  # +File.open+. This is mostly useful on Ruby 1.9 for specifying encoding
+  # options, e.g.:
+  #
+  #   Better::Tempfile.new('hello', '/home/aisaka', :encoding => 'ascii-8bit')
+  #   
+  #   # You can also omit the 'tmpdir' parameter:
+  #   Better::Tempfile.new('hello', :encoding => 'ascii-8bit')
+  #
+  # === Exceptions
+  # 
+  # Under rare circumstances, this constructor can raise an instance of
+  # Better::Tempfile::CreationError. This could happen if a large number
+  # of threads or processes are simultaneously trying to create temp files
+  # and stepping on each others' toes. If Better::Tempfile.new cannot find
+  # a unique filename within a limited number of tries, then it will raise
+  # this exception.
+  def initialize(basename, *rest)
+    # I wish keyword argument settled soon.
+    if rest.last.respond_to?(:to_hash)
+      opts = rest.last.to_hash
+      rest.pop
+    else
+      opts = nil
+    end
+    tmpdir = rest[0] || Dir::tmpdir
+    if $SAFE > 0 && tmpdir.tainted?
+      tmpdir = '/tmp'
+    end
+
+    lock = tmpname = nil
+    n = failure = 0
+    @@lock.synchronize do
+      begin
+        begin
+          tmpname = File.join(tmpdir, make_tmpname(basename, n))
+          lock = tmpname + '.lock'
+          n += 1
+        end while @@live_tempfiles.include?(tmpname) ||
+                  File.exist?(lock) ||
+                  File.exist?(tmpname)
+        self.class.make_directory(lock)
+      rescue SystemCallError
+        failure += 1
+        retry if failure < MAX_TRIES
+        raise CreationError, ("cannot generate tempfile `%s'" % tmpname)
+      end
+    end
+
+    @finalizer_info = [tmpname]
+    @finalizer_callback = self.class.create_finalizer_callback(@finalizer_info)
+    ObjectSpace.define_finalizer(self, @finalizer_callback)
+
+    if opts.nil?
+      opts = []
+    else
+      opts = [opts]
+    end
+    @tmpfile = File.open(tmpname, File::RDWR | File::CREAT | File::EXCL, 0600, *opts)
+    @tmpname = tmpname
+    @@live_tempfiles << tmpname
+    @finalizer_info[1] = @tmpfile
+    @finalizer_info[2] = @@live_tempfiles
+
+    super(@tmpfile)
+
+    # Now we have all the File/IO methods defined, you must not
+    # carelessly put bare puts(), etc. after this.
+
+    Dir.rmdir(lock)
+  end
+  
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, 'r+')
+    @finalizer_info[1] = @tmpfile
+    __setobj__(@tmpfile)
+  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 now.
+  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
+  # <tt>close(true)</tt>.
+  def close!
+    _close
+    unlink if !unlinked?
+  end
+
+  # Unlinks (deletes) the file from the filesystem. One should always unlink
+  # the file after using it, as is explained in the "Explicit close" good
+  # practice section in the Tempfile overview:
+  #
+  #   file = Better::Tempfile.new('foo)
+  #   begin
+  #      ...do something with file...
+  #   ensure
+  #      file.close
+  #      file.unlink   # deletes the temp file
+  #   end
+  #
+  # === Unlink-before-close
+  #
+  # On POSIX systems it's possible to unlink a file before closing it. This
+  # practice is explained in detail in the Tempfile overview (section
+  # "Unlink after creation"); please refer there for more information.
+  #
+  # However, unlink-before-close may not be supported on non-POSIX operating
+  # systems. Microsoft Windows is the most notable case: unlinking a non-closed
+  # file will result in an error, which this method will silently ignore. If
+  # you want to practice unlink-before-close whenever possible, then you should
+  # write code like this:
+  #
+  #   file = Better::Tempfile.new('foo')
+  #   file.unlink   # On Windows this silently fails.
+  #   begin
+  #      ... do something with file ...
+  #   ensure
+  #      file.close!   # Closes the file handle. If the file wasn't unlinked
+  #                    # because #unlink failed, then this method will attempt
+  #                    # to do so again.
+  #   end
+  def unlink
+    begin
+      if File.exist?(@tmpname) # keep this order for thread safeness
+        unlink_file(@tmpname)
+      end
+      @@live_tempfiles.delete(@tmpname)
+      @finalizer_info = @tmpname = nil
+      ObjectSpace.undefine_finalizer(self)
+    rescue Errno::EACCES
+      # may not be able to unlink on Windows; just ignore
+    end
+  end
+  alias delete unlink
+  
+  # Returns whether #unlink has been called on this Tempfile, and whether it
+  # succeeded.
+  def unlinked?
+    @tmpname.nil?
+  end
+
+  # Returns the full path name of the temporary file. This will be nil if
+  # #unlink has been called.
+  def path
+    @tmpname
+  end
+
+  # Returns the size of the temporary file.  As a side effect, the IO
+  # buffer is flushed before determining the size.
+  def size
+    if @tmpfile
+      @tmpfile.flush
+      @tmpfile.stat.size
+    else
+      0
+    end
+  end
+  alias length size
+  
+  protected
+    def _close	# :nodoc:
+      @tmpfile.close if @tmpfile
+      @tmpfile = nil
+      @finalizer_info[1] = nil if @finalizer_info
+    end
+    
+  private
+    def unlink_file(filename)
+      File.unlink(filename)
+    end
+    
+    def make_tmpname(basename, n)
+      case basename
+      when Array
+        prefix, suffix = *basename
+      else
+        prefix, suffix = basename, ''
+      end
+
+      t = Time.now.strftime("%Y%m%d")
+      path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+    end
+end
+
+end # module Better

data/test/example_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+output_file = ARGV.shift
+STDOUT.reopen(output_file, "w")

data/test/tempfile_explicit_close_and_unlink_example.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "example_helper"))
+require 'better/tempfile'
+
+file = Better::Tempfile.new('foo')
+path = file.path
+puts path
+file.close!
+File.open(path, "w").close

data/test/tempfile_explicit_unlink_example.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "example_helper"))
+require 'better/tempfile'
+
+file = Better::Tempfile.new('foo')
+path = file.path
+file.unlink
+if file.unlinked?
+  puts path
+  File.open(path, "w").close
+else
+  file.close!
+end

data/test/tempfile_test.rb

@@ -0,0 +1,283 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+require 'better/tempfile'
+require 'thread'
+
+class TempfileTest < Test::Unit::TestCase
+  include Better
+  
+  def teardown
+    if @tempfile
+      @tempfile.close if !@tempfile.closed?
+      @tempfile.unlink if !@tempfile.unlinked?
+    end
+  end
+  
+  def test_basic
+    @tempfile = Tempfile.new("foo")
+    path = @tempfile.path
+    @tempfile.write("hello world")
+    @tempfile.close
+    assert_equal "hello world", File.read(path)
+  end
+  
+  def test_saves_in_dir_tmpdir_by_default
+    @tempfile = Tempfile.new("foo")
+    assert_equal Dir.tmpdir, File.dirname(@tempfile.path)
+  end
+  
+  def test_saves_in_given_directory
+    subdir = File.join(Dir.tmpdir, "tempfile-test-#{rand}")
+    Dir.mkdir(subdir)
+    begin
+      tempfile = Tempfile.new("foo", subdir)
+      tempfile.close
+      begin
+        assert_equal subdir, File.dirname(tempfile.path)
+      ensure
+        tempfile.unlink
+      end
+    ensure
+      Dir.rmdir(subdir)
+    end
+  end
+  
+  def test_basename
+    @tempfile = Tempfile.new("foo")
+    assert_match /^foo/, File.basename(@tempfile.path)
+  end
+  
+  def test_basename_with_suffix
+    @tempfile = Tempfile.new(["foo", ".txt"])
+    assert_match /^foo/, File.basename(@tempfile.path)
+    assert_match /\.txt$/, File.basename(@tempfile.path)
+  end
+  
+  def test_raises_creation_error_if_max_tries_surpassed
+    Tempfile.expects(:make_directory).times(Tempfile::MAX_TRIES).raises(Errno::EEXIST)
+    assert_raises(Tempfile::CreationError) do
+      @tempfile = Tempfile.new('foo')
+    end
+  end
+  
+  def test_unlink_and_unlink_p
+    @tempfile = Tempfile.new("foo")
+    path = @tempfile.path
+    assert !@tempfile.unlinked?
+    
+    @tempfile.close
+    assert !@tempfile.unlinked?
+    assert File.exist?(path)
+    
+    @tempfile.unlink
+    assert @tempfile.unlinked?
+    assert !File.exist?(path)
+    
+    @tempfile = nil
+  end
+  
+  def test_unlink_makes_path_nil
+    @tempfile = Tempfile.new("foo")
+    @tempfile.close
+    @tempfile.unlink
+    assert_nil @tempfile.path
+  end
+  
+  def test_unlink_silently_fails_on_windows
+    tempfile = Tempfile.new("foo")
+    path = tempfile.path
+    begin
+      tempfile.expects(:unlink_file).with(path).raises(Errno::EACCES)
+      assert_nothing_raised do
+        tempfile.unlink
+      end
+      assert !tempfile.unlinked?
+    ensure
+      tempfile.close
+      File.unlink(path)
+    end
+  end
+  
+  def test_unlink_before_close_works_on_posix_systems
+    tempfile = Tempfile.new("foo")
+    begin
+      path = tempfile.path
+      tempfile.unlink
+      if tempfile.unlinked?
+        assert !File.exist?(path)
+        tempfile.write("hello ")
+        tempfile.write("world\n")
+        tempfile.rewind
+        assert_equal "hello world\n", tempfile.read
+      end
+    ensure
+      tempfile.close
+      tempfile.unlink if !tempfile.unlinked?
+    end
+  end
+  
+  def test_close_and_close_p
+    @tempfile = Tempfile.new("foo")
+    assert !@tempfile.closed?
+    @tempfile.close
+    assert @tempfile.closed?
+  end
+  
+  def test_close_with_unlink_now_true_works
+    @tempfile = Tempfile.new("foo")
+    path = @tempfile.path
+    @tempfile.close(true)
+    assert @tempfile.closed?
+    assert @tempfile.unlinked?
+    assert_nil @tempfile.path
+    assert !File.exist?(path)
+  end
+  
+  def test_close_with_unlink_now_true_does_not_unlink_if_already_unlinked
+    @tempfile = Tempfile.new("foo")
+    path = @tempfile.path
+    @tempfile.unlink
+    File.open(path, "w").close
+    begin
+      @tempfile.close(true)
+      assert File.exist?(path)
+    ensure
+      File.unlink(path) rescue nil
+    end
+  end
+  
+  def test_close_bang_works
+    @tempfile = Tempfile.new("foo")
+    path = @tempfile.path
+    @tempfile.close!
+    assert @tempfile.closed?
+    assert @tempfile.unlinked?
+    assert_nil @tempfile.path
+    assert !File.exist?(path)
+  end
+  
+  def test_close_bang_does_not_unlink_if_already_unlinked
+    @tempfile = Tempfile.new("foo")
+    path = @tempfile.path
+    @tempfile.unlink
+    File.open(path, "w").close
+    begin
+      @tempfile.close!
+      assert File.exist?(path)
+    ensure
+      File.unlink(path) rescue nil
+    end
+  end
+  
+  def test_finalizer_does_not_unlink_if_already_unlinked
+    filename = run_script("tempfile_explicit_close_and_unlink_example.rb").strip
+    assert File.exist?(filename)
+    File.unlink(filename)
+    
+    filename = run_script("tempfile_explicit_unlink_example.rb").strip
+    if !filename.empty?
+      # POSIX unlink semantics supported, continue with test
+      assert File.exist?(filename)
+      File.unlink(filename)
+    end
+  end
+  
+  def test_close_does_not_make_path_nil
+    @tempfile = Tempfile.new("foo")
+    @tempfile.close
+    assert_not_nil @tempfile.path
+  end
+  
+  def test_close_flushes_buffer
+    @tempfile = Tempfile.new("foo")
+    @tempfile.write("hello")
+    @tempfile.close
+    assert 5, File.size(@tempfile.path)
+  end
+  
+  def test_tempfile_is_unlinked_when_ruby_exits
+    filename = run_script("tempfile_unlink_on_exit_example.rb").strip
+    assert !File.exist?(filename)
+  end
+  
+  def test_size_flushes_buffer_before_determining_file_size
+    @tempfile = Tempfile.new("foo")
+    @tempfile.write("hello")
+    assert 0, File.size(@tempfile.path)
+    assert 5, @tempfile.size
+    assert 5, File.size(@tempfile.path)
+  end
+  
+  def test_size_works_if_file_is_closed
+    @tempfile = Tempfile.new("foo")
+    @tempfile.write("hello")
+    @tempfile.close
+    assert 5, @tempfile.size
+  end
+  
+  def test_concurrency
+    threads = []
+    tempfiles = []
+    lock = Mutex.new
+    cond = ConditionVariable.new
+    start = false
+    
+    4.times do
+      threads << Thread.new do
+        lock.synchronize do
+          while !start
+            cond.wait(lock)
+          end
+        end
+        result = []
+        30.times do
+          result << Tempfile.new('foo')
+        end
+        Thread.current[:result] = result
+      end
+    end
+    
+    lock.synchronize do
+      start = true
+      cond.broadcast
+    end
+    threads.each do |thread|
+      thread.join
+      tempfiles |= thread[:result]
+    end
+    filenames = tempfiles.map { |f| f.path }
+    begin
+      assert_equal filenames.size, filenames.uniq.size
+    ensure
+      tempfiles.each do |tempfile|
+        tempfile.close!
+      end
+    end
+  end
+  
+  if defined?(Encoding)
+    def test_tempfile_encoding_nooption
+      default_external = Encoding.default_external
+      t = Tempfile.new("TEST")
+      t.write("\xE6\x9D\xBE\xE6\xB1\x9F")
+      t.rewind
+      assert_equal(default_external, t.read.encoding)
+    end
+    
+    def test_tempfile_encoding_ascii8bit
+      default_external = Encoding.default_external
+      t = Tempfile.new("TEST", :encoding => "ascii-8bit")
+      t.write("\xE6\x9D\xBE\xE6\xB1\x9F")
+      t.rewind
+      assert_equal(Encoding::ASCII_8BIT, t.read.encoding)
+    end
+    
+    def test_tempfile_encoding_ascii8bit2
+      default_external = Encoding.default_external
+      t = Tempfile.new("TEST", Dir::tmpdir, :encoding => "ascii-8bit")
+      t.write("\xE6\x9D\xBE\xE6\xB1\x9F")
+      t.rewind
+      assert_equal(Encoding::ASCII_8BIT, t.read.encoding)
+    end
+  end
+end
+

data/test/tempfile_unlink_on_exit_example.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "example_helper"))
+require 'better/tempfile'
+
+puts Better::Tempfile.new('foo').path

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+require 'rubygems'
+require 'test/unit'
+require 'rbconfig'
+require 'better/tempfile'
+require 'mocha' # must be included last, otherwise it won't work!
+
+def run_script(script, *args)
+  output = Better::Tempfile.new('output')
+  begin
+    output.close
+    
+    ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']) + Config::CONFIG['EXEEXT']
+    command = [ruby, File.join(File.dirname(__FILE__), script), output.path, *args]
+    
+    if system(*command)
+      File.read(output.path)
+    else
+      raise "Command failed: #{command.join(' ')}"
+    end
+  ensure
+    output.close if !output.closed?
+    output.unlink
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: better
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Hongli Lai
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-28 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Collection of better replacements for Ruby standard libraries.
+email: hongli@phusion.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- LICENSE
+- better.gemspec
+- Rakefile
+- lib/better/tempfile.rb
+- lib/better/override/tempfile.rb
+- test/test_helper.rb
+- test/example_helper.rb
+- test/tempfile_test.rb
+- test/tempfile_explicit_close_and_unlink_example.rb
+- test/tempfile_explicit_unlink_example.rb
+- test/tempfile_unlink_on_exit_example.rb
+has_rdoc: true
+homepage: http://better.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: better
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Collection of better replacements for Ruby standard libraries
+test_files: []
+