io-like 0.2.0 → 0.3.0

data/NEWS

@@ -6,6 +6,17 @@ 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.3.0 (2009/04/29)
+
+* Fixed the rewind method to work with write-only streams
+* Fixed the read, gets, and readline methods to return partial data if they have
+  such data but receive low level errors before reaching a stopping point
+* Renamed all private methods so that it is highly unlikely that they will be
+  accidentally overridden.
+* Eliminated warnings caused by referencing uninitialized instance variables
+* Improved the documentation for the read, gets, and readline methods
+
+
 == v0.2.0 (2009/03/11)
 
 * Added mspec tests borrowed from the rubyspec project

data/README

@@ -78,7 +78,7 @@ A simple ROT13 codec:
       encode_rot13(@delegate_io.sysread(length))
     end
 
-    def unbuffered_seek(offset, whence = IO::SEEKSET)
+    def unbuffered_seek(offset, whence = IO::SEEK_SET)
       @delegate_io.sysseek(offset, whence)
     end
 
@@ -109,6 +109,20 @@ A simple ROT13 codec:
     end
   end
 
+  File.open('normal_file.txt') do |f|
+    ROT13Filter.open(f) do |rot13|
+      rot13.pos = 5
+      puts(rot13.read)                      # -> vf n grfg
+    end
+  end
+
+  File.open('rot13_file.txt') do |f|
+    ROT13Filter.open(f) do |rot13|
+      rot13.pos = 5
+      puts(rot13.read)                      # -> is a test
+    end
+  end
+
   File.open('normal_file.txt') do |f|
     ROT13Filter.open(f) do |rot13|
       ROT13Filter.open(rot13) do |rot26|    # ;-)

data/lib/io/like.rb

@@ -29,9 +29,10 @@ class IO # :nodoc:
   #     ...
   #   end
   #
-  # This method must return the number of bytes written to the stream and
-  # should raise SystemCallError on errors.  Errno::EAGAIN should be raised if
-  # no data can be written immediately and the write operation should not block.
+  # This method must either return the number of bytes written to the stream,
+  # which may be less than the length of _string_ in bytes, OR must raise an
+  # instance of SystemCallError.  Errno::EAGAIN should be raised if no data can
+  # be written immediately and the write operation should not block.
   # Errno::EINTR should be raised if the write operation is interrupted before
   # any data is written.
   #
@@ -100,9 +101,9 @@ class IO # :nodoc:
     # returns +true+ and then sets a flag so that #closed? will return +true+.
     def close
       raise IOError, 'closed stream' if closed?
-      @__io_like__closed_read = true
+      __io_like__close_read
       flush if writable?
-      @__io_like__closed_write = true
+      __io_like__close_write
       nil
     end
 
@@ -117,11 +118,11 @@ class IO # :nodoc:
     # if #writable? returns +true+.
     def close_read
       raise IOError, 'closed stream' if closed?
-      if @__io_like__closed_read || ! duplexed? && writable? then
+      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
+        __io_like__close_read
       else
         close
       end
@@ -139,12 +140,12 @@ class IO # :nodoc:
     # if #readable? returns +true+.
     def close_write
       raise IOError, 'closed stream' if closed?
-      if @__io_like__closed_write || ! duplexed? && readable? then
+      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
+        __io_like__close_write
       else
         close
       end
@@ -157,8 +158,8 @@ class IO # :nodoc:
     # Returns +true+ if this object is closed or otherwise unusable for read and
     # write operations.
     def closed?
-      (@__io_like__closed_read || ! readable?) &&
-      (@__io_like__closed_write || ! writable?)
+      (__io_like__closed_read? || ! readable?) &&
+      (__io_like__closed_write? || ! writable?)
     end
 
     # call-seq:
@@ -302,7 +303,7 @@ class IO # :nodoc:
     # #unbuffered_write.
     def flush
       begin
-        buffered_flush
+        __io_like__buffered_flush
       rescue Errno::EAGAIN, Errno::EINTR
         retry if write_ready?
       end
@@ -370,8 +371,11 @@ class IO # :nodoc:
     #
     # Calls #readline with _sep_string_ as an argument and either returns the
     # result or +nil+ if #readline raises EOFError.  If #readline returns some
-    # data, the returned data is assigned to <tt>$_</tt> and <tt>$.</tt> is set
-    # to the value of #lineno.
+    # data, <tt>$.</tt> is set to the value of #lineno.
+    #
+    # <b>NOTE:</b> Due to limitations of MRI up to version 1.9.x when running
+    # managed (Ruby) code, this method fails to set <tt>$_</tt> to the returned
+    # data; however, other implementations may allow it.
     #
     # Raises IOError if #closed? returns +true+.  Raises IOError unless
     # #readable? returns +true+.  Raises all errors raised by #unbuffered_read
@@ -379,9 +383,9 @@ class IO # :nodoc:
     #
     # <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.
+    # this method will always block in that case.  Aside from that exception,
+    # this method will 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)
@@ -484,8 +488,8 @@ class IO # :nodoc:
     # 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)
+      __io_like__buffered_flush if writable? && ! duplexed?
+      __io_like__buffered_seek(0, IO::SEEK_CUR)
     end
     alias :tell :pos
 
@@ -616,7 +620,7 @@ class IO # :nodoc:
         line = arg.nil? ?
                  'nil' :
                  arg.kind_of?(Array) ?
-                   array_join(arg, ors) :
+                   __io_like__array_join(arg, ors) :
                    arg.to_s
         line += ors if line.index(ors, -ors.length).nil?
         write(line)
@@ -633,8 +637,10 @@ class IO # :nodoc:
     # left to fulfill the request.  If the read starts at the end of data, +nil+
     # is returned.
     #
-    # 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 _length_ is unspecified or +nil+, an attempt to return all remaining
+    # data is made.  Partial data will be returned if a low-level error is
+    # raised after some data is retrieved.  If no data would be returned at all,
+    # an empty String is returned.
     #
     # 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
@@ -657,15 +663,18 @@ class IO # :nodoc:
         # Read and return everything.
         begin
           loop do
-            buffer << buffered_read(4096)
+            buffer << __io_like__buffered_read(4096)
           end
         rescue EOFError
           # Ignore this.
+        rescue SystemCallError
+          # Reraise the error if there is nothing to return.
+          raise if buffer.empty?
         end
       else
         # Read and return up to length bytes.
         begin
-          buffer << buffered_read(length)
+          buffer << __io_like__buffered_read(length)
         rescue EOFError
           # Return nil to the caller at end of file when requesting a specific
           # amount of data.
@@ -706,7 +715,7 @@ class IO # :nodoc:
     # provides the #unbuffered_read method but may not always be open in a
     # readable mode.
     def readable?
-      ! @__io_like__closed_read && respond_to?(:unbuffered_read, true)
+      ! __io_like__closed_read? && respond_to?(:unbuffered_read, true)
     end
 
     # call-seq:
@@ -751,7 +760,7 @@ class IO # :nodoc:
     # exception, this method will also raise the same errors and block at the
     # same times as #unbuffered_read.
     def readchar
-      buffered_read(1)[0]
+      __io_like__buffered_read(1)[0]
     rescue Errno::EAGAIN, Errno::EINTR
       retry if read_ready?
     end
@@ -760,14 +769,27 @@ class IO # :nodoc:
     #   ios.readline(sep_string = $/) -> string
     #
     # Returns the next line from the stream, where lines are separated by
-    # _sep_string_.  Increments #lineno.
+    # _sep_string_.  Increments #lineno by <tt>1</tt> for each call regardless
+    # of the value of _sep_string_.
+    #
+    # If _sep_string_ is not +nil+ and not a String, it is first converted to a
+    # String using its +to_str+ method and processing continues as follows.
     #
     # If _sep_string_ is +nil+, a line is defined as the remaining contents of
-    # 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).
+    # the stream.  Partial data will be returned if a low-level error of any
+    # kind is raised after some data is retrieved.  This is equivalent to
+    # calling #read without any arguments except that this method will raise an
+    # EOFError if called at the end of the stream.
+    #
+    # If _sep_string_ is an empty String, a paragraph is returned, where a
+    # paragraph is defined as data followed by 2 or more successive newline
+    # characters.  A maximum of 2 newlines are returned at the end of the
+    # returned data.  Fewer may be returned if the stream ends before at least 2
+    # successive newlines are seen.
+    #
+    # Any other value for _sep_string_ is used as a delimiter to mark the end of
+    # a line.  The returned data includes this delimiter unless the stream ends
+    # before the delimiter is seen.
     #
     # In any case, the end of the stream terminates the current line.
     #
@@ -777,8 +799,8 @@ class IO # :nodoc:
     #
     # <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
+    # this method will always block in that case.  Aside from that exception,
+    # this method will raise the same errors and block at the same times as
     # #unbuffered_read.
     def readline(sep_string = $/)
       # Ensure that sep_string is either nil or a String.
@@ -792,7 +814,7 @@ class IO # :nodoc:
           # A nil line separator means that the user wants to capture all the
           # remaining input.
           loop do
-            buffer << buffered_read(4096)
+            buffer << __io_like__buffered_read(4096)
           end
         else
           begin
@@ -806,7 +828,7 @@ class IO # :nodoc:
             # 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 = buffered_read(1)) do
+                  (char = __io_like__buffered_read(1)) do
               buffer << char
             end
 
@@ -814,7 +836,7 @@ 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 == "\n" && (char = buffered_read(1)) do
+              while char == "\n" && (char = __io_like__buffered_read(1)) do
                 nil
               end
               # Put back the last character.
@@ -824,7 +846,8 @@ class IO # :nodoc:
             retry if read_ready?
           end
         end
-      rescue EOFError
+      rescue EOFError, SystemCallError
+        # Reraise the error if there is nothing to return.
         raise if buffer.empty?
       end
       # Increment the number of times this method has returned a "line".
@@ -889,9 +912,9 @@ class IO # :nodoc:
       buffer.slice!(0..-1)
 
       # Read and return up to length bytes.
-      if internal_read_buffer.empty? then
+      if __io_like__internal_read_buffer.empty? then
         begin
-          buffer << buffered_read(length)
+          buffer << __io_like__buffered_read(length)
         rescue Errno::EAGAIN, Errno::EINTR
           retry if read_ready?
         end
@@ -899,7 +922,7 @@ class IO # :nodoc:
         raise IOError, 'closed stream' if closed?
         raise IOError, 'not opened for reading' unless readable?
 
-        buffer << internal_read_buffer.slice!(0, length)
+        buffer << __io_like__internal_read_buffer.slice!(0, length)
       end
       buffer
     end
@@ -909,7 +932,7 @@ class IO # :nodoc:
     #
     # Sets the position of the file pointer to the beginning of the stream and
     # returns 0 when complete.  The lineno attribute is reset to 0 if
-    # successful.
+    # successful and the stream is readable according to #readable?.
     #
     # As a side effect, the internal read and write buffers are flushed.
     #
@@ -921,7 +944,8 @@ class IO # :nodoc:
     # also raise the same errors and block at the same times as those functions.
     def rewind
       seek(0, IO::SEEK_SET)
-      self.lineno = 0
+      self.lineno = 0 if readable?
+      0
     end
 
     # call-seq:
@@ -944,7 +968,7 @@ class IO # :nodoc:
     # #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)
-      buffered_seek(offset, whence)
+      __io_like__buffered_seek(offset, whence)
       0
     end
 
@@ -1009,12 +1033,12 @@ class IO # :nodoc:
 
       raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
-      unless internal_read_buffer.empty? then
+      unless __io_like__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?
+      __io_like__buffered_flush if writable? && ! duplexed?
 
       buffer << unbuffered_read(length)
     end
@@ -1036,9 +1060,11 @@ class IO # :nodoc:
     # 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?
-      raise IOError, 'sysseek on buffered IO' unless internal_read_buffer.empty?
-      unless internal_write_buffer.empty? then
+      raise Errno::ESPIPE unless seekable?
+      unless __io_like__internal_read_buffer.empty? then
+        raise IOError, 'sysseek on buffered IO'
+      end
+      unless __io_like__internal_write_buffer.empty? then
         warn('warning: sysseek on buffered IO')
       end
 
@@ -1062,15 +1088,15 @@ class IO # :nodoc:
     def syswrite(string)
       raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
-      unless internal_write_buffer.empty? then
+      unless __io_like__internal_write_buffer.empty? then
         warn('warning: syswrite on buffered IO')
       end
 
       # 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)
+      unless duplexed? || __io_like__internal_read_buffer.empty? then
+        unbuffered_seek(-__io_like__internal_read_buffer.length, IO::SEEK_CUR)
+        __io_like__internal_read_buffer.slice!(0..-1)
       end
 
       unbuffered_write(string)
@@ -1107,7 +1133,7 @@ class IO # :nodoc:
     def unread(string)
       raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for reading' unless readable?
-      internal_read_buffer.insert(0, string.to_s)
+      __io_like__internal_read_buffer.insert(0, string.to_s)
       nil
     end
 
@@ -1142,7 +1168,7 @@ class IO # :nodoc:
     # provides the #unbuffered_write method but may not always be open in a
     # writable mode.
     def writable?
-      ! @__io_like__closed_write && respond_to?(:unbuffered_write, true)
+      ! __io_like__closed_write? && respond_to?(:unbuffered_write, true)
     end
 
     # call-seq:
@@ -1168,7 +1194,8 @@ class IO # :nodoc:
       bytes_written = 0
       while bytes_written < string.length do
         begin
-          bytes_written += buffered_write(string.to_s.slice(bytes_written..-1))
+          bytes_written +=
+            __io_like__buffered_write(string.to_s.slice(bytes_written..-1))
         rescue Errno::EAGAIN, Errno::EINTR
           retry if write_ready?
         end
@@ -1179,7 +1206,7 @@ class IO # :nodoc:
     private
 
     # call-seq:
-    #   ios.buffered_flush   -> 0
+    #   ios.__io_like__buffered_flush   -> 0
     #
     # Attempts to completely flush the internal write buffer to the data stream.
     #
@@ -1188,18 +1215,20 @@ class IO # :nodoc:
     # <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
+    def __io_like__buffered_flush
       raise IOError, 'closed stream' if closed?
       raise IOError, 'not opened for writing' unless writable?
 
-      until internal_write_buffer.empty? do
-        internal_write_buffer.slice!(0, unbuffered_write(internal_write_buffer))
+      until __io_like__internal_write_buffer.empty? do
+        __io_like__internal_write_buffer.slice!(
+          0, unbuffered_write(__io_like__internal_write_buffer)
+        )
       end
       0
     end
 
     # call-seq:
-    #   ios.buffered_read(length) -> string
+    #   ios.__io_like__buffered_read(length) -> string
     #
     # Reads at most _length_ bytes first from an internal read buffer followed
     # by the underlying stream if necessary and returns the resulting buffer.
@@ -1210,7 +1239,7 @@ class IO # :nodoc:
     # <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)
+    def __io_like__buffered_read(length)
       # Check the validity of the method arguments.
       raise ArgumentError, "non-positive length #{length} given" if length < 0
 
@@ -1218,30 +1247,30 @@ class IO # :nodoc:
       raise IOError, 'not opened for reading' unless readable?
 
       # Flush the internal write buffer for writable, non-duplexed objects.
-      buffered_flush if writable? && ! duplexed?
+      __io_like__buffered_flush if writable? && ! duplexed?
 
       # Ensure that the internal read buffer has at least enough data to satisfy
       # the request.
-      if internal_read_buffer.length < length then
-        unbuffered_length = length - internal_read_buffer.length
+      if __io_like__internal_read_buffer.length < length then
+        unbuffered_length = length - __io_like__internal_read_buffer.length
         unbuffered_length = fill_size if unbuffered_length < fill_size
 
         begin
-          internal_read_buffer << unbuffered_read(unbuffered_length)
+          __io_like__internal_read_buffer << unbuffered_read(unbuffered_length)
         rescue EOFError, SystemCallError
           # Reraise the error if there is no data to return.
-          raise if internal_read_buffer.empty?
+          raise if __io_like__internal_read_buffer.empty?
         end
       end
 
       # Read from the internal read buffer.
-      buffer = internal_read_buffer.slice!(0, length)
+      buffer = __io_like__internal_read_buffer.slice!(0, length)
 
       buffer
     end
 
     # call-seq:
-    #   ios.buffered_seek(offset[, whence]) -> integer
+    #   ios.__io_like__buffered_seek(offset[, whence]) -> integer
     #
     # Sets the current data position to _offset_ based on the setting of
     # _whence_.  If _whence_ is unspecified or IO::SEEK_SET, _offset_ counts
@@ -1260,37 +1289,40 @@ class IO # :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)
+    def __io_like__buffered_seek(offset, whence = IO::SEEK_SET)
       raise IOError, 'closed stream' if closed?
-      raise Errno::ESPIPE, 'Illegal seek' unless seekable?
+      raise Errno::ESPIPE unless seekable?
 
       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
+        __io_like__internal_read_buffer.empty? ?
+          unbuffered_seek(0, IO::SEEK_CUR) +
+            __io_like__internal_write_buffer.length :
+          unbuffered_seek(0, IO::SEEK_CUR) -
+            __io_like__internal_read_buffer.length
       elsif whence == IO::SEEK_CUR && offset > 0 &&
-            internal_write_buffer.empty? &&
-            offset <= internal_read_buffer.length then
+            __io_like__internal_write_buffer.empty? &&
+            offset <= __io_like__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
+        __io_like__internal_read_buffer.slice!(0, offset)
+        unbuffered_seek(0, IO::SEEK_CUR) -
+          __io_like__internal_read_buffer.length
       else
         # 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
+          offset += __io_like__internal_read_buffer.empty? ?
+            __io_like__internal_write_buffer.length :
+            -__io_like__internal_read_buffer.length
         end
 
         # Flush the internal buffers.
-        internal_read_buffer.slice!(0..-1)
-        buffered_flush if writable?
+        __io_like__internal_read_buffer.slice!(0..-1)
+        __io_like__buffered_flush if writable?
 
         # Move the data stream's position as requested.
         unbuffered_seek(offset, whence)
@@ -1298,7 +1330,7 @@ class IO # :nodoc:
     end
 
     # call-seq:
-    #   ios.buffered_write(string) -> integer
+    #   ios.__io_like__buffered_write(string) -> integer
     #
     # Writes _string_ to the internal write buffer and returns the number of
     # bytes written.  If the internal write buffer is overfilled by _string_, it
@@ -1311,51 +1343,72 @@ class IO # :nodoc:
     # 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)
+    def __io_like__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.
-      unless duplexed? || internal_read_buffer.empty? then
-        unbuffered_seek(-internal_read_buffer.length, IO::SEEK_CUR)
-        internal_read_buffer.slice!(0..-1)
+      unless duplexed? || __io_like__internal_read_buffer.empty? then
+        unbuffered_seek(-__io_like__internal_read_buffer.length, IO::SEEK_CUR)
+        __io_like__internal_read_buffer.slice!(0..-1)
       end
 
       bytes_written = 0
       if sync then
         # Flush the internal write buffer and then bypass it when in synchronous
         # mode.
-        buffered_flush
+        __io_like__buffered_flush
         bytes_written = unbuffered_write(string)
       else
-        if internal_write_buffer.length + string.length >= flush_size then
+        if __io_like__internal_write_buffer.length + string.length >= flush_size then
           # The tipping point for the write buffer would be surpassed by this
           # request, so flush everything.
-          buffered_flush
+          __io_like__buffered_flush
           bytes_written = unbuffered_write(string)
         else
           # The buffer can absorb the entire request.
-          internal_write_buffer << string
+          __io_like__internal_write_buffer << string
           bytes_written = string.length
         end
       end
-    rescue SystemCallError
-      raise if bytes_written == 0
-    else
       return bytes_written
     end
 
     # Returns a reference to the internal read buffer.
-    def internal_read_buffer
+    def __io_like__internal_read_buffer
       @__io_like__read_buffer ||= ''
     end
 
     # Returns a reference to the internal write buffer.
-    def internal_write_buffer
+    def __io_like__internal_write_buffer
       @__io_like__write_buffer ||= ''
     end
 
+    # Returns +true+ if this object has been closed for reading; otherwise,
+    # returns +false+.
+    def __io_like__closed_read?
+      @__io_like__closed_read ||= false
+    end
+
+    # Arranges for #__io_like__closed_read? to return +true+.
+    def __io_like__close_read
+      @__io_like__closed_read = true
+      nil
+    end
+
+    # Returns +true+ if this object has been closed for writing; otherwise,
+    # returns +false+.
+    def __io_like__closed_write?
+      @__io_like__closed_write ||= false
+    end
+
+    # Arranges for #__io_like__closed_write? to return +true+.
+    def __io_like__close_write
+      @__io_like__closed_write = true
+      nil
+    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.
@@ -1375,21 +1428,18 @@ class IO # :nodoc:
     #
     # Things get progressively worse as the nesting and recursion become more
     # convoluted.
-    def array_join(array, separator, seen = [])
-      first = true
+    def __io_like__array_join(array, separator, seen = [])
       seen.push(array.object_id)
+      need_separator = false
       result = array.inject('') do |memo, item|
-        if first then
-          first = false
-        else
-          memo << separator
-        end
+        memo << separator if need_separator
+        need_separator = true
 
         memo << if item.kind_of?(Array) then
                   if seen.include?(item.object_id) then
                     '[...]'
                   else
-                    array_join(item, separator, seen)
+                    __io_like__array_join(item, separator, seen)
                   end
                 else
                   item.to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: io-like
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jeremy Bopp
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-11 00:00:00 -05:00
+date: 2009-04-29 00:00:00 -05:00
 default_executable: 
 dependencies: []