io-like 0.1.0 → 0.2.0

data/CONTRIBUTORS

@@ -6,6 +6,8 @@
 
 = Bug Fixes
 
+* Jarred Holman <jarred.holman at gmail dot com>
+
 
 = Testers
 

data/HACKING

@@ -17,8 +17,8 @@ some cases, but such cases will be rare.
 === Build
 
 * rubygems 0.9.0 or greater
-* rake 0.8.1
-* rubyforge 1.0.0 (optional - used for publishing releases)
+* rake 0.8.3 or greater
+* mspec 1.5.9 (optional - used for testing)
 * allison 2.0.3 (optional - used for documentation only, if available)
 * rsync (optional - used for publishing documentation)
 

data/LEGAL

@@ -5,4 +5,52 @@
 The following file(s) are provided under a license or licenses separate from
 this project.
 
-  None at present
+See LICENSE.rubyspec for terms of use for the following:
+  spec/binmode_spec.rb
+  spec/close_read_spec.rb
+  spec/close_spec.rb
+  spec/close_write_spec.rb
+  spec/closed_spec.rb
+  spec/each_byte_spec.rb
+  spec/each_line_spec.rb
+  spec/each_spec.rb
+  spec/eof_spec.rb
+  spec/fixtures/classes.rb
+  spec/fixtures/gets.txt
+  spec/fixtures/numbered_lines.txt
+  spec/fixtures/one_byte.txt
+  spec/fixtures/paragraphs.txt
+  spec/fixtures/readlines.txt
+  spec/flush_spec.rb
+  spec/getc_spec.rb
+  spec/gets_spec.rb
+  spec/isatty_spec.rb
+  spec/lineno_spec.rb
+  spec/output_spec.rb
+  spec/pos_spec.rb
+  spec/print_spec.rb
+  spec/printf_spec.rb
+  spec/putc_spec.rb
+  spec/puts_spec.rb
+  spec/read_spec.rb
+  spec/readchar_spec.rb
+  spec/readline_spec.rb
+  spec/readlines_spec.rb
+  spec/readpartial_spec.rb
+  spec/rewind_spec.rb
+  spec/seek_spec.rb
+  spec/shared/each.rb
+  spec/shared/eof.rb
+  spec/shared/pos.rb
+  spec/shared/tty.rb
+  spec/shared/write.rb
+  spec/sync_spec.rb
+  spec/sysread_spec.rb
+  spec/sysseek_spec.rb
+  spec/syswrite_spec.rb
+  spec/tell_spec.rb
+  spec/to_io_spec.rb
+  spec/tty_spec.rb
+  spec/ungetc_spec.rb
+  spec/write_spec.rb
+  spec_helper.rb

data/LICENSE.rubyspec

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Engine Yard, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/MANIFEST

@@ -3,8 +3,8 @@ GPL
 HACKING
 LEGAL
 LICENSE
+LICENSE.rubyspec
 MANIFEST
 NEWS
 README
 lib/io/like.rb
-test/lib/likestringio.rb

data/NEWS

@@ -6,6 +6,13 @@ detailed information is available in the rest of the documentation.
 <b>NOTE:</b> Date stamps in the following entries are in YYYY/MM/DD format.
 
 
+== v0.2.0 (2009/03/11)
+
+* Added mspec tests borrowed from the rubyspec project
+* Fixed many, many defects related to IO compatibility (Mostly obscure corner
+  cases)
+
+
 == v0.1.0 (2008/07/03)
 
 * Initial release

data/README

@@ -12,11 +12,14 @@ methods.
 
 == License
 
-Copyright © 2008 Jeremy Bopp <jeremy at bopp dot net>
+Copyright © 2008,2009 Jeremy Bopp <jeremy at bopp dot net>
 
 Licensed under the same terms as Ruby -- See the included LICENSE file for
 details
 
+Some parts licensed under the same terms as the rubyspec project -- See the
+included LEGAL and LICENSE.rubyspec files for details
+
 
 == Installation/Removal
 
@@ -125,8 +128,6 @@ A simple ROT13 codec:
    collected.  Define a class open method in the manner of File.open which
    guarantees that an appropriate close method will be called after executing a
    block.  Other than that, be diligent about calling the close methods.
-3. Testcases needed.  Maybe use some of rubyspec along with some test classes
-   act like the important parts of IO, File, and/or StringIO.
 
 
 == Contributing

data/lib/io/like.rb

@@ -100,77 +100,65 @@ class IO # :nodoc:
     # returns +true+ and then sets a flag so that #closed? will return +true+.
     def close
       raise IOError, 'closed stream' if closed?
-      if duplexed? then
-        close_read unless closed_read?
-        close_write unless closed_write?
-      else
-        flush if writable?
-        @__io_like__closed = true
-      end
+      @__io_like__closed_read = true
+      flush if writable?
+      @__io_like__closed_write = true
       nil
     end
 
     # call-seq:
     #   ios.close_read       -> nil
     #
-    # For duplexed objects, arranges for #closed_read? to return +true+.
+    # Closes the read end of a duplexed object or the whole object if the object
+    # is read-only.
     #
-    # Raises IOError if #duplexed returns +false+.  Raises IOError if
-    # #closed_read? returns +true+.
+    # Raises IOError if #closed? returns +true+.  Raises IOError for duplexed
+    # objects if called more than once.  Raises IOError for non-duplexed objects
+    # if #writable? returns +true+.
     def close_read
-      raise IOError, 'closed stream' if closed_read?
-      raise IOError, 'closing non-duplex IO for reading' unless duplexed?
-      @__io_like__closed_read = true
+      raise IOError, 'closed stream' if closed?
+      if @__io_like__closed_read || ! duplexed? && writable? then
+        raise IOError, 'closing non-duplex IO for reading'
+      end
+      if duplexed? then
+        @__io_like__closed_read = true
+      else
+        close
+      end
       nil
     end
 
     # call-seq:
     #   ios.close_write      -> nil
     #
-    # For duplexed objects, calls #flush and arranges for #closed_write? to
-    # return +true+.
+    # Closes the write end of a duplexed object or the whole object if the
+    # object is write-only.
     #
-    # Raises IOError if #duplexed? returns +false+.  Raises IOError if
-    # #closed_write? returns +true+.
+    # Raises IOError if #closed? returns +true+.  Raises IOError for duplexed
+    # objects if called more than once.  Raises IOError for non-duplexed objects
+    # if #readable? returns +true+.
     def close_write
-      raise IOError, 'closed stream' if closed_write?
-      raise IOError, 'closing non-duplex IO for writing' unless duplexed?
-      flush
-      @__io_like__closed_write = true
+      raise IOError, 'closed stream' if closed?
+      if @__io_like__closed_write || ! duplexed? && readable? then
+        raise IOError, 'closing non-duplex IO for reading'
+      end
+      if duplexed? then
+        flush
+        @__io_like__closed_write = true
+      else
+        close
+      end
       nil
     end
 
     # call-seq:
     #   ios.closed?          -> true or false
     #
-    # For non-duplexed objects, returns +true+ if #close was called, +false+
-    # otherwise.  For duplexed objects, returns +true+ if both #closed_read?
-    # and #closed_write? return true.
+    # Returns +true+ if this object is closed or otherwise unusable for read and
+    # write operations.
     def closed?
-      return closed_read? && closed_write? if duplexed?
-      @__io_like__closed || false
-    end
-
-    # call-seq:
-    #   ios.closed_read?     -> true or false
-    #
-    # Returns the result of calling #closed? for non-duplexed objects.  For
-    # duplexed objects, returns +true+ if close_read was called, +false+
-    # otherwise.
-    def closed_read?
-      return closed? unless duplexed?
-      @__io_like__closed_read || false
-    end
-
-    # call-seq:
-    #   ios.closed_write?    -> true or false
-    #
-    # Returns the result of calling #closed? for non-duplexed objects.  For
-    # duplexed objects, returns +true+ if close_write was called, +false+
-    # otherwise.
-    def closed_write?
-      return closed? unless duplexed?
-      @__io_like__closed_read || false
+      (@__io_like__closed_read || ! readable?) &&
+      (@__io_like__closed_write || ! writable?)
     end
 
     # call-seq:
@@ -183,12 +171,12 @@ class IO # :nodoc:
     end
 
     # call-seq:
-    #   ios.each_byte {|byte| block} -> ios
+    #   ios.each_byte { |byte| block } -> ios
     #
     # Reads each byte (0..255) from the stream using #getc and calls the given
     # block once for each byte, passing the byte as an argument.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_read.  Therefore, this method always blocks.  Aside from that
     # exception and the conversion of EOFError results into +nil+ results, this
     # method will also raise the same errors and block at the same times as
@@ -201,17 +189,17 @@ class IO # :nodoc:
     end
 
     # call-seq:
-    #   ios.each_line(sep_string = $/) {|line| block } -> ios
-    #   ios.each(sep_string = $/) {|line| block } -> ios
+    #   ios.each_line(sep_string = $/) { |line| block } -> ios
+    #   ios.each(sep_string = $/) { |line| block } -> ios
     #
     # Reads each line from the stream using #gets and calls the given block once
     # for each line, passing the line as an argument.
     #
-    # NOTE: When _sep_string_ is not +nil+, this method ignores Errno::EAGAIN
-    # and Errno::EINTR raised by #unbuffered_read.  Therefore, this method
-    # always blocks.  Aside from that exception and the conversion of EOFError
-    # results into +nil+ results, this method will also raise the same errors
-    # and block at the same times as #unbuffered_read.
+    # <b>NOTE:</b> When _sep_string_ is not +nil+, this method ignores
+    # Errno::EAGAIN and Errno::EINTR raised by #unbuffered_read.  Therefore,
+    # this method always blocks.  Aside from that exception and the conversion
+    # of EOFError results into +nil+ results, this method will also raise the
+    # same errors and block at the same times as #unbuffered_read.
     def each_line(sep_string = $/)
       while (line = gets(sep_string)) do
         yield(line)
@@ -230,7 +218,7 @@ class IO # :nodoc:
     # put the character back if one was fetched.  It may be a good idea to
     # replace this implementation in derivative classes.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_read.  Therefore, this method always blocks.  Aside from that
     # exception and the conversion of EOFError results into +nil+ results, this
     # method will also raise the same errors and block at the same times as
@@ -247,7 +235,7 @@ class IO # :nodoc:
     # call-seq:
     #   ios.fcntl
     #
-    # Raises NotImplementedError
+    # Raises NotImplementedError.
     def fcntl(*args)
       raise NotImplementedError, 'not implemented'
     end
@@ -267,10 +255,10 @@ class IO # :nodoc:
     # buffer needs to be refilled.  Unless set explicitly via #fill_size=, this
     # defaults to 4096.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError if the
+    # Raises IOError if #closed? returns +true+.  Raises IOError if the
     # stream is not opened for reading.
     def fill_size
-      raise IOError, 'closed stream' if closed_read?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
 
       @__io_like__fill_size ||= 4096
@@ -283,10 +271,10 @@ class IO # :nodoc:
     # buffer needs to be refilled.  The new value must be a number greater than
     # or equal to 0.  Setting this to 0 effectively disables buffering.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError if the
+    # Raises IOError if #closed? returns +true+.  Raises IOError if the
     # stream is not opened for reading.
     def fill_size=(fill_size)
-      raise IOError, 'closed stream' if closed_read?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
 
       unless fill_size >= 0 then
@@ -304,17 +292,15 @@ class IO # :nodoc:
     # during writing, this method will block until either all the data is
     # flushed or until an error is raised.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_write.  Therefore, this method always blocks if unable to
     # flush the internal write buffer.  Aside from that exception, this
     # method will also raise the same errors and block at the same times as
     # #unbuffered_write.
     def flush
-      raise IOError, 'closed stream' if closed_write?
-
       begin
         buffered_flush
       rescue Errno::EAGAIN, Errno::EINTR
@@ -330,10 +316,10 @@ class IO # :nodoc:
     # automatically to the data stream.  Unless set explicitly via #flush_size=,
     # this defaults to 4096.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     def flush_size
-      raise IOError, 'closed stream' if closed_write?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
 
       @__io_like__flush_size ||= 4096
@@ -346,10 +332,10 @@ class IO # :nodoc:
     # automatically to the data stream.  The new value must be a number greater
     # than or equal to 0.  Setting this to 0 effectively disables buffering.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     def flush_size=(flush_size)
-      raise IOError, 'closed stream' if closed_write?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
 
       unless flush_size >= 0 then
@@ -364,11 +350,11 @@ class IO # :nodoc:
     # Calls #readchar and either returns the result or +nil+ if #readchar raises
     # EOFError.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.  Raises all errors raised by #unbuffered_read
     # except for EOFError.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_read.  Therefore, this method always blocks.  Aside from that
     # exception and the conversion of EOFError results into +nil+ results, this
     # method will also raise the same errors and block at the same times as
@@ -387,15 +373,15 @@ class IO # :nodoc:
     # data, the returned data is assigned to <tt>$_</tt> and <tt>$.</tt> is set
     # to the value of #lineno.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.  Raises all errors raised by #unbuffered_read
     # except for EOFError.
     #
-    # NOTE: When _sep_string_ is not +nil+, this method ignores Errno::EAGAIN
-    # and Errno::EINTR raised by #unbuffered_read.  Therefore, this method
-    # always blocks.  Aside from that exception and the conversion of EOFError
-    # results into +nil+ results, this method will also raise the same errors
-    # and block at the same times as #unbuffered_read.
+    # <b>NOTE:</b> When _sep_string_ is not +nil+, this method ignores
+    # Errno::EAGAIN and Errno::EINTR raised by #unbuffered_read.  Therefore,
+    # this method always blocks.  Aside from that exception and the conversion
+    # of EOFError results into +nil+ results, this method will also raise the
+    # same errors and block at the same times as #unbuffered_read.
     def gets(sep_string = $/)
       # Set the last read line in the global.
       $_ = readline(sep_string)
@@ -411,7 +397,10 @@ class IO # :nodoc:
     #   ios.isatty           -> false
     #
     # Returns +false+.  Just for compatibility with IO.
+    #
+    # Raises IOError if #closed? returns +true+.
     def isatty
+      raise IOError, 'closed stream' if closed?
       false
     end
     alias :tty? :isatty
@@ -424,10 +413,10 @@ class IO # :nodoc:
     # the other line-based reading methods with a non-default value for
     # _sep_string_ or after changing <tt>$/</tt> will affect this.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.
     def lineno
-      raise IOError, 'closed stream' if closed_read?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
       @__io_like__lineno ||= 0
     end
@@ -436,14 +425,20 @@ class IO # :nodoc:
     #   ios.lineno = lineno  -> lineno
     #
     # Sets the current line number to the given value.  <tt>$.</tt> is updated
-    # by the _next_ call to #gets.
+    # by the _next_ call to #gets.  If the object given is not an integer, it is
+    # converted to one using its to_int method.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.
     def lineno=(integer)
-      raise IOError, 'closed stream' if closed_read?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
-      @__io_like__lineno = integer
+      if integer.nil? then
+        raise TypeError, 'no implicit conversion from nil to integer'
+      elsif ! integer.respond_to?(:to_int) then
+        raise TypeError, "can't convert #{integer.class} into Integer"
+      end
+      @__io_like__lineno = integer.to_int
     end
 
     # call-seq:
@@ -464,14 +459,36 @@ class IO # :nodoc:
     # Raises IOError if #closed? returns +true+.  Raises Errno::ESPIPE unless
     # #seekable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_seek and #unbuffered_write
-    # (when the internal write buffer is not empty), it will also raise the same
-    # errors and block at the same times as those functions.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_seek and
+    # #unbuffered_write (when the internal write buffer is not empty), it will
+    # also raise the same errors and block at the same times as those functions.
     def pos=(position)
       seek(position, IO::SEEK_SET)
       position
     end
 
+    # call-seq:
+    #   ios.pos              -> integer
+    #
+    # Returns the current offest of ios.
+    #
+    # Raises IOError if #closed? returns +true+.  Raises Errno::ESPIPE unless
+    # #seekable? returns +true+.
+    #
+    # As a side effect, the internal write buffer is flushed unless this is
+    # a writable, non-duplexed object.  This is for compatibility with the
+    # behavior of IO#pos.
+    #
+    # <b>NOTE:</b> Because this method relies on #unbuffered_seek and
+    # #unbuffered_write (when the internal write buffer is not empty), it will
+    # also raise the same errors and block at the same times as those functions.
+    def pos
+      # Flush the internal write buffer for writable, non-duplexed objects.
+      buffered_flush if writable? && ! duplexed?
+      buffered_seek(0, IO::SEEK_CUR)
+    end
+    alias :tell :pos
+
     # call-seq:
     #   ios.print([obj, ...]) -> nil
     #
@@ -482,10 +499,10 @@ class IO # :nodoc:
     # record separator (<tt>$\\</tt>) is written after all other data if it is
     # not nil.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_write.  Therefore, this method always blocks if unable to
     # immediately write +[obj, ...]+ completely.  Aside from that exception,
     # this method will also raise the same errors and block at the same times as
@@ -522,10 +539,10 @@ class IO # :nodoc:
     # Writes the String returned by calling Kernel.sprintf using the given
     # arguments.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_write.  Therefore, this method always blocks if unable to
     # immediately write its arguments completely.  Aside from that exception,
     # this method will also raise the same errors and block at the same times as
@@ -538,23 +555,23 @@ class IO # :nodoc:
     # call-seq:
     #   ios.putc(obj)        -> obj
     #
-    # If _obj_ is Numeric, write the result of <tt>obj.chr</tt>; otherwise,
-    # write the first character of <tt>obj.to_s</tt>.
+    # If _obj_ is a String, write the first byte; otherwise, convert _obj_ to a
+    # integer using its _to_int_ method and write the low order byte.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_write.  Therefore, this method always blocks if unable to
     # immediately write _obj_ completely.  Aside from that exception, this
     # method will also raise the same errors and block at the same times as
     # #unbuffered_write.
     def putc(obj)
       char = case obj
-             when Numeric
-               obj.chr
+             when String
+               obj[0].chr
              else
-               obj.to_s[0].chr
+               [obj.to_int].pack('V')[0].chr
              end
       write(char)
       obj
@@ -569,18 +586,18 @@ class IO # :nodoc:
     # is written after each object which does not end with the record separator
     # already.  If no objects are given, a single record separator is written.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_write.  Therefore, this method always blocks if unable to
     # immediately write +[obj, ...]+ completely.  Aside from that exception,
     # this method will also raise the same errors and block at the same times as
     # #unbuffered_write.
     #
-    # NOTE: In order to be compatible with IO#puts, the record separator is
-    # currently hardcoded to be a single newline (<tt>"\n"</tt>) even though the
-    # documentation implies that the output record separator (<tt>$\\</tt>)
+    # <b>NOTE:</b> In order to be compatible with IO#puts, the record separator
+    # is currently hardcoded to be a single newline (<tt>"\n"</tt>) even though
+    # the documentation implies that the output record separator (<tt>$\\</tt>)
     # should be used.
     def puts(*args)
       # Set the output record separator such that this method is compatible with
@@ -596,13 +613,13 @@ class IO # :nodoc:
       # Write each argument followed by the record separator.  Recursively
       # process arguments which are Array instances.
       args.each do |arg|
-        if arg.kind_of?(Array) then
-          puts(*arg)
-        else
-          line = arg.nil? ? 'nil' : arg.to_s
-          line += ors if line.index(ors, -ors.length).nil?
-          write(line)
-        end
+        line = arg.nil? ?
+                 'nil' :
+                 arg.kind_of?(Array) ?
+                   array_join(arg, ors) :
+                   arg.to_s
+        line += ors if line.index(ors, -ors.length).nil?
+        write(line)
       end
 
       nil
@@ -619,22 +636,22 @@ class IO # :nodoc:
     # If _length_ is unspecified or +nil+, all remaining data is returned.  If
     # no data would be returned at all, an empty String is returned.
     #
-    # If _buffer_ is specified, it is assumed to be a String and will be filled
-    # with the returned data if any.
+    # If _buffer_ is specified, it will be converted to a String using its
+    # +to_str+ method if necessary and will be filled with the returned data if
+    # any.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_read, it will also raise
-    # the same errors and block at the same times as that function.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_read, it will also
+    # raise the same errors and block at the same times as that function.
     def read(length = nil, buffer = nil)
       # Check the validity of the method arguments.
       unless length.nil? || length >= 0 then
         raise ArgumentError, "negative length #{length} given"
       end
-      buffer = '' if buffer.nil?
-      # Flush the buffer.
-      buffer.slice!(0..-1)
+      buffer = buffer.nil? ? '' : buffer.to_str
+      buffer.slice!(0..-1) unless buffer.empty?
 
       if length.nil? then
         # Read and return everything.
@@ -667,8 +684,8 @@ class IO # :nodoc:
     # This default implementation of #read_ready? is a hack which should be able
     # to work for both real IO objects and IO-like objects; however, it is
     # inefficient since it merely sleeps for 1 second and then returns +true+ as
-    # long as #closed_read? returns +false+.  IO.select should be used for real
-    # IO objects to wait for a readable condition on platforms with support for
+    # long as #closed? returns +false+.  IO.select should be used for real IO
+    # objects to wait for a readable condition on platforms with support for
     # IO.select.  Other solutions should be found as necessary to improve this
     # implementation on a case by case basis.
     #
@@ -684,12 +701,12 @@ class IO # :nodoc:
     #
     # Returns +true+ if the stream is both open and readable, +false+ otherwise.
     #
-    # This implementation calls #closed_read? and checks to see if
-    # #unbuffered_read is defined in order to make its determination.  Override
-    # this if the implementing class always provides the #unbuffered_read method
-    # but may not always be open in a readable mode.
+    # This implementation checks to see if #unbuffered_read is defined in order
+    # to make its determination.  Override this if the implementing class always
+    # provides the #unbuffered_read method but may not always be open in a
+    # readable mode.
     def readable?
-      ! closed_read? && respond_to?(:unbuffered_read, true)
+      ! @__io_like__closed_read && respond_to?(:unbuffered_read, true)
     end
 
     # call-seq:
@@ -698,17 +715,17 @@ class IO # :nodoc:
     # Reads and returns _length_ bytes from the data stream.
     #
     # Raises EOFError if reading begins at the end of the stream.  Raises
-    # IOError if #closed_read? returns +true+.  Raises IOError unless
-    # #readable? returns +true+.  Raises TruncatedDataError if insufficient
-    # data is immediately available to satisfy the request.
+    # IOError if #closed? returns +true+.  Raises IOError unless #readable?
+    # returns +true+.  Raises TruncatedDataError if insufficient data is
+    # immediately available to satisfy the request.
     #
     # In the case of TruncatedDataError being raised, the retrieved data can be
     # fetched from the _data_ attribute of the exception.
     #
     # This method is basically copied from IO#readbytes.
     #
-    # NOTE: Because this method relies on #unbuffered_read, it will also raise
-    # the same errors and block at the same times as that function.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_read, it will also
+    # raise the same errors and block at the same times as that function.
     def readbytes(length)
       buffer = read(length)
       if buffer.nil? then
@@ -726,15 +743,14 @@ class IO # :nodoc:
     # Returns the next 8-bit byte (0..255) from the stream.
     #
     # Raises EOFError when there is no more data in the stream.  Raises IOError
-    # if #closed_read? returns +true+.  Raises IOError unless #readable? returns
+    # if #closed? returns +true+.  Raises IOError unless #readable? returns
     # +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_read.  Therefore, this method always blocks.  Aside from that
     # exception, this method will also raise the same errors and block at the
     # same times as #unbuffered_read.
     def readchar
-      raise IOError, 'closed stream' if closed_read?
       buffered_read(1)[0]
     rescue Errno::EAGAIN, Errno::EINTR
       retry if read_ready?
@@ -747,22 +763,28 @@ class IO # :nodoc:
     # _sep_string_.  Increments #lineno.
     #
     # If _sep_string_ is +nil+, a line is defined as the remaining contents of
-    # the stream.  If _sep_string_ is empty, a paragraph is returned, where a
-    # paragraph is defined as data followed by 2 or more successive newline
-    # characters (only 2 newlines are returned at the end of the returned data).
+    # the stream.  If _sep_string_ is not a String, it is converted to one using
+    # its +to_str+ method.  If _sep_string_ is empty, a paragraph is returned,
+    # where a paragraph is defined as data followed by 2 or more successive
+    # newline characters (only 2 newlines are returned at the end of the
+    # returned data).
     #
     # In any case, the end of the stream terminates the current line.
     #
     # Raises EOFError when there is no more data in the stream.  Raises IOError
-    # if #closed_read? returns +true+.  Raises IOError unless #readable? returns
+    # if #closed? returns +true+.  Raises IOError unless #readable? returns
     # +true+.
     #
-    # NOTE: When _sep_string_ is not +nil+, this method ignores Errno::EAGAIN
-    # and Errno::EINTR raised by #unbuffered_read.  Therefore, this method
-    # always blocks.  Aside from that exception, this method will also raise the
-    # same errors and block at the same times as #unbuffered_read.
+    # <b>NOTE:</b> When _sep_string_ is not +nil+, this method ignores
+    # Errno::EAGAIN and Errno::EINTR raised by #unbuffered_read.  Therefore,
+    # this method always blocks.  Aside from that exception, this method will
+    # also raise the same errors and block at the same times as
+    # #unbuffered_read.
     def readline(sep_string = $/)
-      raise IOError, 'closed stream' if closed_read?
+      # Ensure that sep_string is either nil or a String.
+      unless sep_string.nil? || sep_string.kind_of?(String) then
+        sep_string = sep_string.to_str
+      end
 
       buffer = ''
       begin
@@ -777,14 +799,14 @@ class IO # :nodoc:
             # Record if the user requested paragraphs rather than lines.
             paragraph_requested = sep_string.empty?
             # An empty line separator string indicates that the user wants to
-            # return paragraphs.  A pair of newlines in the stream is used to mark
-            # this.
+            # return paragraphs.  A pair of newlines in the stream is used to
+            # mark this.
             sep_string = "\n\n" if paragraph_requested
 
             # Add each character from the input to the buffer until either the
             # buffer has the right ending or the end of the input is reached.
             while buffer.index(sep_string, -sep_string.length).nil? &&
-                  (char = readchar) do
+                  (char = buffered_read(1)) do
               buffer << char
             end
 
@@ -792,7 +814,9 @@ class IO # :nodoc:
               # If the user requested paragraphs instead of lines, we need to
               # consume and discard all newlines remaining at the front of the
               # input.
-              while (char = readchar) && char == "\n" do; end
+              while char == "\n" && (char = buffered_read(1)) do
+                nil
+              end
               # Put back the last character.
               ungetc(char[0])
             end
@@ -814,20 +838,23 @@ class IO # :nodoc:
     # Returns an Array containing the lines in the stream using #each_line.
     #
     # If _sep_string_ is +nil+, a line is defined as the remaining contents of
-    # the stream.  If _sep_string_ is empty, a paragraph is returned, where a
-    # paragraph is defined as data followed by 2 or more successive newline
-    # characters (only 2 newlines are returned at the end of the returned data).
+    # the stream.  If _sep_string_ is not a String, it is converted to one using
+    # its +to_str+ method.  If _sep_string_ is empty, a paragraph is returned,
+    # where a paragraph is defined as data followed by 2 or more successive
+    # newline characters (only 2 newlines are returned at the end of the
+    # returned data).
     #
     # In any case, the end of the stream terminates the current line.
     #
     # Raises EOFError when there is no more data in the stream.  Raises IOError
-    # if #closed_read? returns +true+.  Raises IOError unless #readable? returns
+    # if #closed? returns +true+.  Raises IOError unless #readable? returns
     # +true+.
     #
-    # NOTE: When _sep_string_ is not +nil+, this method ignores Errno::EAGAIN
-    # and Errno::EINTR raised by #unbuffered_read.  Therefore, this method
-    # always blocks.  Aside from that exception, this method will also raise the
-    # same errors and block at the same times as #unbuffered_read.
+    # <b>NOTE:</b> When _sep_string_ is not +nil+, this method ignores
+    # Errno::EAGAIN and Errno::EINTR raised by #unbuffered_read.  Therefore,
+    # this method always blocks.  Aside from that exception, this method will
+    # also raise the same errors and block at the same times as
+    # #unbuffered_read.
     def readlines(sep_string = $/)
       lines = []
       each_line(sep_string) { |line| lines << line }
@@ -844,10 +871,10 @@ class IO # :nodoc:
     # whether or not the data stream would block.
     #
     # Raises EOFError when there is no more data in the stream.  Raises IOError
-    # if #closed_read? returns +true+.  Raises IOError unless #readable? returns
+    # if #closed? returns +true+.  Raises IOError unless #readable? returns
     # +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_read.  Therefore, this method always blocks if unable to
     # immediately return _length_ bytes.  Aside from that exception, this method
     # will also raise the same errors and block at the same times as
@@ -861,9 +888,6 @@ class IO # :nodoc:
       # Flush the buffer.
       buffer.slice!(0..-1)
 
-      raise IOError, 'closed stream' if closed_read?
-      raise IOError, 'not opened for reading' unless readable?
-
       # Read and return up to length bytes.
       if internal_read_buffer.empty? then
         begin
@@ -872,6 +896,9 @@ class IO # :nodoc:
           retry if read_ready?
         end
       else
+        raise IOError, 'closed stream' if closed?
+        raise IOError, 'not opened for reading' unless readable?
+
         buffer << internal_read_buffer.slice!(0, length)
       end
       buffer
@@ -889,9 +916,9 @@ class IO # :nodoc:
     # Raises IOError if #closed? returns +true+.  Raises Errno::ESPIPE unless
     # #seekable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_seek and #unbuffered_write
-    # (when the internal write buffer is not empty), it will also raise the same
-    # errors and block at the same times as those functions.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_seek and
+    # #unbuffered_write (when the internal write buffer is not empty), it will
+    # also raise the same errors and block at the same times as those functions.
     def rewind
       seek(0, IO::SEEK_SET)
       self.lineno = 0
@@ -906,17 +933,17 @@ class IO # :nodoc:
     # counts from the end of the data (_offset_ should be negative here).  If
     # _whence_ is IO::SEEK_CUR, _offset_ is relative to the current position.
     #
-    # As a side effect, the internal read and write buffers are flushed.
+    # As a side effect, the internal read and write buffers are flushed except
+    # when seeking relative to the current position (whence is IO::SEEK_CUR) to
+    # a location within the internal read buffer.
     #
     # Raises IOError if #closed? returns +true+.  Raises Errno::ESPIPE unless
     # #seekable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_seek and #unbuffered_write
-    # (when the internal write buffer is not empty), it will also raise the same
-    # errors and block at the same times as those functions.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_seek and
+    # #unbuffered_write (when the internal write buffer is not empty), it will
+    # also raise the same errors and block at the same times as those functions.
     def seek(offset, whence = IO::SEEK_SET)
-      raise IOError, 'closed stream' if closed?
-
       buffered_seek(offset, whence)
       0
     end
@@ -924,14 +951,14 @@ class IO # :nodoc:
     # call-seq:
     #   ios.seekable?        -> true or false
     #
-    # Returns +true+ if the stream is both open and seekable, +false+ otherwise.
+    # Returns +true+ if the stream is seekable, +false+ otherwise.
     #
-    # This implementation calls #closed? and checks to see if #unbuffered_seek
-    # is defined in order to make its determination.  Override this if the
-    # implementing class always provides the #unbuffered_seek method but may not
-    # always be seekable.
+    # This implementation always returns +false+ for duplexed objects and
+    # checks to see if #unbuffered_seek is defined in order to make its
+    # determination otherwise.  Override this if the implementing class always
+    # provides the #unbuffered_seek method but may not always be seekable.
     def seekable?
-      ! closed? && respond_to?(:unbuffered_seek, true)
+      ! duplexed? && respond_to?(:unbuffered_seek, true)
     end
 
     # call-seq:
@@ -940,9 +967,9 @@ class IO # :nodoc:
     # Returns true if the internal write buffer is currently being bypassed,
     # false otherwise.
     #
-    # Raises IOError if #closed_write? returns +true+.
+    # Raises IOError if #closed? returns +true+.
     def sync
-      raise IOError, 'closed stream' if closed_write?
+      raise IOError, 'closed stream' if closed?
       @__io_like__sync ||= false
     end
 
@@ -954,10 +981,10 @@ class IO # :nodoc:
     # operation.  When set to +false+, the internal write buffer will be
     # enabled.
     #
-    # Raises IOError if #closed_write? returns +true+.
+    # Raises IOError if #closed? returns +true+.
     def sync=(sync)
-      raise IOError, 'closed stream' if closed_write?
-      @__io_like__sync = sync
+      raise IOError, 'closed stream' if closed?
+      @__io_like__sync = sync ? true : false
     end
 
     # call-seq:
@@ -971,38 +998,42 @@ class IO # :nodoc:
     #
     # Raises EOFError if reading begins at the end of the stream.  Raises
     # IOError if the internal read buffer is not empty.  Raises IOError if
-    # #closed_read? returns +true+.
+    # #closed? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_read, it will also raise
-    # the same errors and block at the same times as that function.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_read, it will also
+    # raise the same errors and block at the same times as that function.
     def sysread(length, buffer = nil)
-      buffer = '' if buffer.nil?
-      buffer.slice!(0..-1)
+      buffer = buffer.nil? ? '' : buffer.to_str
+      buffer.slice!(0..-1) unless buffer.empty?
       return buffer if length == 0
 
-      raise IOError, 'closed stream' if closed_read?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
       unless internal_read_buffer.empty? then
         raise IOError, 'sysread on buffered IO'
       end
 
+      # Flush the internal write buffer for writable, non-duplexed objects.
+      buffered_flush if writable? && ! duplexed?
+
       buffer << unbuffered_read(length)
     end
 
     # call-seq:
-    #   ios.sysseek(offset, whence) -> integer
+    #   ios.sysseek(offset[, whence]) -> integer
     #
-    # Sets the data pointer of the data stream to the position requested by
-    # _offset_ and _whence_ and returns the new position.
+    # Sets the current data position to _offset_ based on the setting of
+    # _whence_.  If _whence_ is unspecified or IO::SEEK_SET, _offset_ counts
+    # from the beginning of the data.  If _whence_ is IO::SEEK_END, _offset_
+    # counts from the end of the data (_offset_ should be negative here).  If
+    # _whence_ is IO::SEEK_CUR, _offset_ is relative to the current position.
     #
     # Raises IOError if the internal read buffer is not empty.  Raises IOError
-    # if #closed? returns +true+.
+    # if #closed? returns +true+.  Raises Errno::ESPIPE unless #seekable?
+    # returns +true+.
     #
-    # See the description of the operation of #unbuffered_seek for information
-    # concerning how to interpret _offset_ and _whence_.
-    #
-    # NOTE: Because this method relies on #unbuffered_seek, it will also raise
-    # the same errors and block at the same times as that function.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_seek, it will also
+    # raise the same errors and block at the same times as that function.
     def sysseek(offset, whence = IO::SEEK_SET)
       raise IOError, 'closed stream' if closed?
       raise Errno::ESPIPE, 'Illegal seek' unless seekable?
@@ -1010,6 +1041,7 @@ class IO # :nodoc:
       unless internal_write_buffer.empty? then
         warn('warning: sysseek on buffered IO')
       end
+
       unbuffered_seek(offset, whence)
     end
 
@@ -1022,46 +1054,27 @@ class IO # :nodoc:
     # As a side effect for non-duplex objects, the internal read buffer is
     # flushed.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_write, it will also raise
-    # the same errors and block at the same times as that function.
+    # <b>NOTE:</b> Because this method relies on #unbuffered_write, it will also
+    # raise the same errors and block at the same times as that function.
     def syswrite(string)
-      raise IOError, 'closed stream' if closed_write?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
-      unless duplexed? || internal_read_buffer.empty? then
-        internal_read_buffer.slice(0..-1)
-      end
       unless internal_write_buffer.empty? then
         warn('warning: syswrite on buffered IO')
       end
 
-      unbuffered_write(string)
-    end
-
-    # call-seq:
-    #   ios.tell             -> integer
-    #
-    # Returns the current offest of ios.
-    #
-    # Raises IOError if #closed? returns +true+.  Raises Errno::ESPIPE unless
-    # #seekable? returns +true+.
-    #
-    # As a side effect, the internal write buffer is flushed unless this is
-    # a duplexed object.  This is for compatibility with the behavior of
-    # IO#tell.
-    #
-    # NOTE: Because this method relies on #unbuffered_seek and #unbuffered_write
-    # (when the internal write buffer is not empty), it will also raise the same
-    # errors and block at the same times as those functions.
-    def tell
-      raise IOError, 'closed stream' if closed?
+      # Flush the internal read buffer and set the unbuffered position to the
+      # buffered position when dealing with non-duplexed objects.
+      unless duplexed? || internal_read_buffer.empty? then
+        unbuffered_seek(-internal_read_buffer.length, IO::SEEK_CUR)
+        internal_read_buffer.slice!(0..-1)
+      end
 
-      buffered_flush unless internal_write_buffer.empty?
-      buffered_tell
+      unbuffered_write(string)
     end
-    alias :pos :tell
 
     # call-seq:
     #   ios.to_io            -> ios
@@ -1076,7 +1089,7 @@ class IO # :nodoc:
     #
     # Calls #unread with <tt>integer.chr</tt> as an argument.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.
     def ungetc(integer)
       unread(integer.chr)
@@ -1089,12 +1102,12 @@ class IO # :nodoc:
     # returns +nil+.  If _string_ is not a String, it is converted to one using
     # its +to_s+ method.
     #
-    # Raises IOError if #closed_read? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.
     def unread(string)
-      raise IOError, 'closed stream' if closed_read?
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
-      internal_read_buffer.insert(0, data.to_s)
+      internal_read_buffer.insert(0, string.to_s)
       nil
     end
 
@@ -1107,7 +1120,7 @@ class IO # :nodoc:
     # This default implementation of #write_ready? is a hack which should be
     # able to work for both real IO objects and IO-like objects; however, it is
     # inefficient since it merely sleeps for 1 second and then returns +true+ as
-    # long as #closed_write? returns +false+.  IO.select should be used for real
+    # long as #closed? returns +false+.  IO.select should be used for real
     # IO objects to wait for a writeable condition on platforms with support for
     # IO.select.  Other solutions should be found as necessary to improve this
     # implementation on a case by case basis.
@@ -1124,12 +1137,12 @@ class IO # :nodoc:
     #
     # Returns +true+ if the stream is both open and writable, +false+ otherwise.
     #
-    # This implementation calls #closed_write? and checks to see if
-    # #unbuffered_write is defined in order to make its determination.  Override
-    # this if the implementing class always provides the #unbuffered_write
-    # method but may not always be open in a writable mode.
+    # This implementation checks to see if #unbuffered_write is defined in order
+    # to make its determination.  Override this if the implementing class always
+    # provides the #unbuffered_write method but may not always be open in a
+    # writable mode.
     def writable?
-      ! closed_write? && respond_to?(:unbuffered_write, true)
+      ! @__io_like__closed_write && respond_to?(:unbuffered_write, true)
     end
 
     # call-seq:
@@ -1140,18 +1153,18 @@ class IO # :nodoc:
     # convert it into one.  The entire contents of _string_ are written,
     # blocking as necessary even if the data stream does not block.
     #
-    # Raises IOError if #closed_write? returns +true+.  Raises IOError unless
+    # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #writable? returns +true+.
     #
-    # NOTE: This method ignores Errno::EAGAIN and Errno::EINTR raised by
+    # <b>NOTE:</b> This method ignores Errno::EAGAIN and Errno::EINTR raised by
     # #unbuffered_write.  Therefore, this method always blocks if unable to
     # immediately write _string_ completely.  Aside from that exception, this
     # method will also raise the same errors and block at the same times as
     # #unbuffered_write.
     def write(string)
-      raise IOError, 'closed stream' if closed_write?
-
       string = string.to_s
+      return 0 if string.empty?
+
       bytes_written = 0
       while bytes_written < string.length do
         begin
@@ -1172,10 +1185,11 @@ class IO # :nodoc:
     #
     # Raises IOError unless #writable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_write, it raises all
-    # errors raised by #unbuffered_write and blocks when #unbuffered_write
+    # <b>NOTE:</b> Because this method relies on #unbuffered_write, it raises
+    # all errors raised by #unbuffered_write and blocks when #unbuffered_write
     # blocks.
-    def buffered_flush # :nodoc:
+    def buffered_flush
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
 
       until internal_write_buffer.empty? do
@@ -1193,17 +1207,18 @@ class IO # :nodoc:
     # Raises EOFError if the internal read buffer is empty and reading begins at
     # the end of the stream.  Raises IOError unless #readable? returns +true+.
     #
-    # NOTE: Because this method relies on #unbuffered_read, it raises all errors
-    # raised by #unbuffered_read and blocks when #unbuffered_read blocks
+    # <b>NOTE:</b> Because this method relies on #unbuffered_read, it raises all
+    # errors raised by #unbuffered_read and blocks when #unbuffered_read blocks
     # whenever the internal read buffer is unable to fulfill the request.
-    def buffered_read(length) # :nodoc:
+    def buffered_read(length)
       # Check the validity of the method arguments.
       raise ArgumentError, "non-positive length #{length} given" if length < 0
 
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
 
-      # Flush the internal write buffer for non-duplexed objects.
-      buffered_flush unless internal_write_buffer.empty? || duplexed?
+      # Flush the internal write buffer for writable, non-duplexed objects.
+      buffered_flush if writable? && ! duplexed?
 
       # Ensure that the internal read buffer has at least enough data to satisfy
       # the request.
@@ -1228,41 +1243,57 @@ class IO # :nodoc:
     # call-seq:
     #   ios.buffered_seek(offset[, whence]) -> integer
     #
-    # Sets the new position for read or write operations using _offset_ and
-    # _whence_ to computer the position.  Returns the new position.
+    # Sets the current data position to _offset_ based on the setting of
+    # _whence_.  If _whence_ is unspecified or IO::SEEK_SET, _offset_ counts
+    # from the beginning of the data.  If _whence_ is IO::SEEK_END, _offset_
+    # counts from the end of the data (_offset_ should be negative here).  If
+    # _whence_ is IO::SEEK_CUR, _offset_ is relative to the current position.
     #
-    # As a side effect, the internal read and write buffers are flushed.
+    # As a side effect, the internal read and write buffers are flushed except
+    # when seeking relative to the current position (whence is IO::SEEK_CUR) to
+    # a location within the internal read buffer.
     #
     # Raises Errno::ESPIPE unless #seekable? returns +true+.
     #
     # See #seek for the usage of _offset_ and _whence_.
     #
-    # NOTE: Because this method relies on #unbuffered_seek and #unbuffered_write
-    # (when the internal write buffer is not empty), it will raise the same
-    # errors and block at the same times as those functions.
-    def buffered_seek(offset, whence = IO::SEEK_SET) # :nodoc:
-      raise Errno::ESPIPE, 'Illegal seek' unless seekable?
-
-      # Flush the internal buffers.
-      internal_read_buffer.slice!(0..-1)
-      buffered_flush unless internal_write_buffer.empty?
-      # Move the data stream's position as requested.
-      unbuffered_seek(offset, whence)
-    end
-
-    # call-seq:
-    #   ios.buffered_tell
-    #
-    # Returns the current position in the stream.
-    #
-    # Raises Errno::ESPIPE unless #seekable? returns +true+.
-    def buffered_tell # :nodoc:
+    # <b>NOTE:</b> Because this method relies on #unbuffered_seek and
+    # #unbuffered_write (when the internal write buffer is not empty), it will
+    # raise the same errors and block at the same times as those functions.
+    def buffered_seek(offset, whence = IO::SEEK_SET)
+      raise IOError, 'closed stream' if closed?
       raise Errno::ESPIPE, 'Illegal seek' unless seekable?
 
-      unless internal_read_buffer.empty? then
+      if whence == IO::SEEK_CUR && offset == 0 then
+        # The seek is only determining the current position, so return the
+        # buffered position based on the read buffer if it's not empty and the
+        # write buffer otherwise.
+        internal_read_buffer.empty? ?
+          unbuffered_seek(0, IO::SEEK_CUR) + internal_write_buffer.length :
+          unbuffered_seek(0, IO::SEEK_CUR) - internal_read_buffer.length
+      elsif whence == IO::SEEK_CUR && offset > 0 &&
+            internal_write_buffer.empty? &&
+            offset <= internal_read_buffer.length then
+        # The seek is within the read buffer, so just discard a sufficient
+        # amount of the buffer and report the new buffered position.
+        internal_read_buffer.slice!(0, offset)
         unbuffered_seek(0, IO::SEEK_CUR) - internal_read_buffer.length
       else
-        unbuffered_seek(0, IO::SEEK_CUR) + internal_write_buffer.length
+        # The seek target is outside of the buffers, so flush the buffers and
+        # jump to the new position.
+        if whence == IO::SEEK_CUR then
+          # Adjust relative offsets based on the current buffered offset.
+          offset += internal_read_buffer.empty? ?
+            internal_write_buffer.length :
+            -internal_read_buffer.length
+        end
+
+        # Flush the internal buffers.
+        internal_read_buffer.slice!(0..-1)
+        buffered_flush if writable?
+
+        # Move the data stream's position as requested.
+        unbuffered_seek(offset, whence)
       end
     end
 
@@ -1276,16 +1307,17 @@ class IO # :nodoc:
     # the internal write buffer cannot be immediately flushed due to the
     # underlying stream not blocking when unable to accept more data.
     #
-    # NOTE: Because this method relies on #unbuffered_write, it raises all
-    # errors raised by #unbuffered_write and blocks when #unbuffered_write
+    # <b>NOTE:</b> Because this method relies on #unbuffered_write, it raises
+    # all errors raised by #unbuffered_write and blocks when #unbuffered_write
     # blocks whenever the internal write buffer is unable to fulfill the
     # request.
-    def buffered_write(string) # :nodoc:
+    def buffered_write(string)
+      raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
 
       # Flush the internal read buffer and set the unbuffered position to the
       # buffered position when dealing with non-duplexed objects.
-      if ! (duplexed? || internal_read_buffer.empty?) then
+      unless duplexed? || internal_read_buffer.empty? then
         unbuffered_seek(-internal_read_buffer.length, IO::SEEK_CUR)
         internal_read_buffer.slice!(0..-1)
       end
@@ -1315,14 +1347,58 @@ class IO # :nodoc:
     end
 
     # Returns a reference to the internal read buffer.
-    def internal_read_buffer # :nodoc:
+    def internal_read_buffer
       @__io_like__read_buffer ||= ''
     end
 
     # Returns a reference to the internal write buffer.
-    def internal_write_buffer # :nodoc:
+    def internal_write_buffer
       @__io_like__write_buffer ||= ''
     end
+
+    # This method joins the elements of _array_ together with _separator_
+    # between each element and returns the result.  _seen_ is a list of object
+    # IDs representing arrays which have already started processing.
+    #
+    # This method exists only because Array#join apparently behaves in an
+    # implementation dependent manner when joining recursive arrays and so does
+    # not always produce the expected results.  Specifically, MRI 1.8.6 and
+    # 1.8.7 behave as follows:
+    #
+    #   x = []
+    #   x << 1 << x << 2
+    #   x.join(', ')              => "1, 1, [...], 2, 2"
+    #
+    # The expected and necessary result for use with #puts is:
+    #
+    #   "1, [...], 2"
+    #
+    # Things get progressively worse as the nesting and recursion become more
+    # convoluted.
+    def array_join(array, separator, seen = [])
+      first = true
+      seen.push(array.object_id)
+      result = array.inject('') do |memo, item|
+        if first then
+          first = false
+        else
+          memo << separator
+        end
+
+        memo << if item.kind_of?(Array) then
+                  if seen.include?(item.object_id) then
+                    '[...]'
+                  else
+                    array_join(item, separator, seen)
+                  end
+                else
+                  item.to_s
+                end
+      end
+      seen.pop
+
+      result
+    end
   end
 end