progressive_io 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e46f28055cb41f75b5a00b863d1771580ec7e610dd09d5360574e123c3b99867
-  data.tar.gz: b9ff8b9bf2724da050eb49933eac10c9d35953c30abd823fcc0482823a27a3a8
+  metadata.gz: 384d400209c61ff65f9298a602c53b8b6ce6cdf837d56b58a6e4cb900e932377
+  data.tar.gz: 0e68bbc55b01864b300a451496ba3c4e86839ec4f34bfb7d2f7cec9cb47fb415
 SHA512:
-  metadata.gz: e9c3bdfaf294545502b5dcde2381f67c4d343df02c64d9b56d290877f13619d283288a64517af7e5c5aa7f7359db6a0606684f693c0b8cdec9c32abfd2d27a43
-  data.tar.gz: 14fbce5195814ef1c583c664f8550b664e60d2d46a1465ef7ced873bd980247897fea75652f36444c4ff5511c67ba8be64dcd25644a310f907cd80d9f68ba236
+  metadata.gz: 43468779c7d211dbacacb79918c4fb719f100c67fb1cfaf31a881ba82cf1b8681aa21e48dd0ee34d90cfda2c74d06e29410813245f0f1c4fc300cab8d5c24fc9
+  data.tar.gz: e1a5cf367640e3bfb6b97ec527ff2cb570a76b06425fd8df644d83f8beb7f2db5ca335c03762f473b97c70840604ee1ce9010bd321dd9b722393fa94f2e4bffa

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 2.1.0
+
+* Report `readpartial`, `read_nonblock`, `sysread`, `getbyte`, `readbyte`, `each_char` and
+  `each_codepoint`, which went past the wrapper unreported.
+* `IO.copy_stream` reports now. It read a wrapped File by opening its path itself, and a wrapped
+  IO through `to_io`, so the wrapper no longer passes on `to_path` or `to_io` - reach the
+  wrapped IO with `__getobj__` where you need it (`IO.select`, say). Without them
+  `IO.copy_stream` reads through `readpartial`, which also means no zero-copy fast path.
+* Pass keyword arguments on: `gets(chomp: true)`, `readline`, `readlines`, `each` and
+  `each_line` used to raise `TypeError`.
+* Work with pipes and sockets. Every read raised `Errno::ESPIPE`, since reporting asked the IO
+  for its position; for a stream without one, the bytes read so far are reported instead, and
+  `ungetc`/`ungetbyte` take pushed-back bytes off that count.
+* Require Ruby 3.2.
+
 ## 2.0.2
 
 * Fix `each_line` to return an Enumerator that properly references `:each_line` method

data/README.md

@@ -8,7 +8,9 @@ A wrapper for IO objects that allows a callback to be set which is called when a
 
 ## FEATURES/PROBLEMS
 
-* Wraps any IO
+* Wraps any IO: files, StringIO, pipes and sockets
+* Reports every kind of read, including `readpartial`, so `IO.copy_stream` reports too
+* On a pipe or a socket, which have no position, reports the bytes read so far instead
 
 ## SYNOPSIS
 
@@ -42,9 +44,17 @@ io_with_progress.each do | line | # Each yielded line will call the callback blo
 end
 ```
 
+Copying reports as it goes:
+
+```ruby
+IO.copy_stream(ProgressiveIO.new(File.open("/bigfile.dat")) { |pos| pbar.set(pos) }, destination)
+```
+
+The wrapper does not pass on `to_io` or `to_path`, since `IO.copy_stream` would use them to read the file past it. To get at the wrapped IO, use `__getobj__`.
+
 ## REQUIREMENTS
 
-* Ruby 1.8.6+
+* Ruby 3.2+
 
 ## INSTALL
 

data/lib/progressive_io.rb

@@ -3,45 +3,52 @@
 require 'delegate'
 
 # A wrapper class that provides progress tracking for IO operations.
-# 
+#
 # This class wraps an IO object and calls a progress block whenever data is read,
 # allowing you to track reading progress for operations like file uploads or downloads.
-# 
+#
+# The block receives the position after each read. A pipe, a socket or a TTY has no position,
+# so for those it receives the number of bytes read through the wrapper so far instead.
+#
 # @example Basic usage with a file
 #   file = File.open('large_file.txt')
 #   progress_io = ProgressiveIO.new(file) do |current_pos|
 #     puts "Read #{current_pos} bytes"
 #   end
-#   
+#
 #   progress_io.each_line do |line|
 #     # Process each line
 #   end
-# 
+#
 # @example Usage with a StringIO
 #   string_io = StringIO.new("Hello\nWorld\n")
 #   progress_io = ProgressiveIO.new(string_io) do |current_pos|
 #     puts "Read #{current_pos} bytes"
 #   end
-#   
+#
 #   content = progress_io.read
-# 
+#
+# @example Copying, which reads through readpartial
+#   IO.copy_stream(ProgressiveIO.new(source) { |pos| bar.update(pos) }, destination)
+#
 # @since 2.0.0
 class ProgressiveIO < SimpleDelegator
   # The version of the ProgressiveIO library
-  VERSION = '2.0.2'
-  
+  VERSION = '2.1.0'
+
   # @return [Proc, nil] The progress callback block that will be called when data is read
   #   The block receives one parameter: current position
   attr_accessor :progress_block
-  
+
   # Creates a new ProgressiveIO wrapper around an IO object.
-  # 
-  # @param with_io [IO] The IO object to wrap (File, StringIO, etc.)
+  #
+  # @param with_io [IO] The IO object to wrap (File, StringIO, a pipe, etc.)
   # @param blk [Proc, nil] Optional block that will be called when data is read
   #   The block receives one parameter: current position
   # @yield [current_pos] The progress callback
-  # @yieldparam current_pos [Integer] The current position in the IO stream
-  # 
+  # @yieldparam current_pos [Integer] The current position in the IO stream, or the bytes
+  #   read so far for a stream that has no position
+  #
   # @example
   #   file = File.open('data.txt')
   #   progress_io = ProgressiveIO.new(file) do |pos|
@@ -50,170 +57,324 @@ class ProgressiveIO < SimpleDelegator
   def initialize(with_io, &blk)
     super(with_io)
     @progress_block = blk.to_proc if blk
+    @positioned = nil
+    @consumed = 0
   end
-  
+
   # Iterates over the IO stream line by line, calling the progress block for each line.
-  # 
+  #
   # @param args [Array] Arguments to pass to the underlying IO#each method (separator and/or limit)
+  # @param kwargs [Hash] Keyword arguments to pass on, such as `chomp: true`
   # @yield [line] Each line from the IO stream
   # @yieldparam line [String] A line from the IO stream
   # @return [Enumerator] An enumerator if no block is given
-  # 
+  #
   # @example
   #   progress_io.each do |line|
   #     puts "Processing: #{line.chomp}"
   #   end
-  # 
+  #
   # @example Using as an Enumerator
   #   progress_io.each.with_index do |line, idx|
   #     puts "Line #{idx}: #{line.chomp}"
   #   end
-  def each(*args, &blk)
-    return enum_for(__method__, *args) unless block_given?
-    
+  def each(*args, **kwargs, &blk)
+    return enum_for(__method__, *args, **kwargs) unless block_given?
+
     # Report offset at each call of the iterator
-    super(*args) do |line|
-      yield(line).tap { notify_read }
+    super(*args, **kwargs) do |line|
+      yield(line).tap { notify_read(line, chomped: kwargs[:chomp]) }
     end
   end
-  
+
   # Iterates over the IO stream line by line, calling the progress block for each line.
   # This is an alias-like method for {#each} that ensures proper Enumerator behavior.
-  # 
+  #
   # @param args [Array] Arguments to pass to the underlying IO#each_line method (separator and/or limit)
+  # @param kwargs [Hash] Keyword arguments to pass on, such as `chomp: true`
   # @yield [line] Each line from the IO stream
   # @yieldparam line [String] A line from the IO stream
   # @return [Enumerator] An enumerator if no block is given
-  # 
+  #
   # @example
   #   progress_io.each_line do |line|
   #     puts "Processing: #{line.chomp}"
   #   end
-  # 
+  #
   # @example Using as an Enumerator
   #   progress_io.each_line.with_index do |line, idx|
   #     puts "Line #{idx}: #{line.chomp}"
   #   end
-  def each_line(*args, &blk)
-    return enum_for(__method__, *args) unless block_given?
-    
-    each(*args, &blk)
+  def each_line(*args, **kwargs, &blk)
+    return enum_for(__method__, *args, **kwargs) unless block_given?
+
+    each(*args, **kwargs, &blk)
   end
-  
+
   # Iterates over the IO stream byte by byte, calling the progress block for each byte.
-  # 
+  #
   # @yield [byte] Each byte from the IO stream
   # @yieldparam byte [Integer] A byte from the IO stream (0-255)
   # @return [Enumerator] An enumerator if no block is given
-  # 
+  #
   # @example
   #   progress_io.each_byte do |byte|
   #     puts "Byte: #{byte}"
   #   end
-  # 
+  #
   # @example Using as an Enumerator
   #   progress_io.each_byte.with_index do |byte, idx|
   #     puts "Byte #{idx}: #{byte}"
   #   end
   def each_byte(&blk)
     return enum_for(__method__) unless block_given?
-    
+
     # Report offset at each call of the iterator
-    super { |b| yield(b).tap { notify_read } }
+    super { |b| yield(b).tap { notify_read(b) } }
+  end
+
+  # Iterates over the IO stream character by character, calling the progress block for each.
+  #
+  # @yield [char] Each character from the IO stream
+  # @yieldparam char [String] A character from the IO stream
+  # @return [Enumerator] An enumerator if no block is given
+  # @since 2.1.0
+  def each_char(&blk)
+    return enum_for(__method__) unless block_given?
+
+    super { |c| yield(c).tap { notify_read(c) } }
+  end
+
+  # Iterates over the IO stream codepoint by codepoint, calling the progress block for each.
+  #
+  # @yield [codepoint] Each codepoint from the IO stream
+  # @yieldparam codepoint [Integer] A codepoint from the IO stream
+  # @return [Enumerator] An enumerator if no block is given
+  # @since 2.1.0
+  def each_codepoint(&blk)
+    return enum_for(__method__) unless block_given?
+
+    super { |c| yield(c).tap { notify_read(codepoint_string(c)) } }
   end
-  
+
   # Reads a single character from the IO stream.
-  # 
+  #
   # @return [String, nil] The next character or nil if at end of stream
   # @see IO#getc
   def getc
-    super.tap { notify_read }
+    super.tap { |c| notify_read(c) }
   end
-  
+
+  # Reads a single byte from the IO stream.
+  #
+  # @return [Integer, nil] The next byte or nil if at end of stream
+  # @see IO#getbyte
+  # @since 2.1.0
+  def getbyte
+    super.tap { |b| notify_read(b) }
+  end
+
   # Reads a line from the IO stream.
-  # 
+  #
   # @param args [Array] Arguments to pass to the underlying IO#gets method
+  # @param kwargs [Hash] Keyword arguments to pass on, such as `chomp: true`
   # @return [String, nil] The next line or nil if at end of stream
   # @see IO#gets
-  def gets(*args)
-    super(*args).tap { notify_read }
+  def gets(*args, **kwargs)
+    super(*args, **kwargs).tap { |line| notify_read(line, chomped: kwargs[:chomp]) }
   end
-  
+
   # Reads data from the IO stream.
-  # 
+  #
   # @param a [Array] Arguments to pass to the underlying IO#read method
   # @return [String, nil] The read data or nil if at end of stream
   # @see IO#read
   def read(*a)
-    super(*a).tap { notify_read }
+    super(*a).tap { |data| notify_read(data) }
   end
-  
+
+  # Reads at most a number of bytes, blocking only if none are available. IO.copy_stream reads
+  # through this when its source is not an IO itself.
+  #
+  # @param a [Array] Arguments to pass to the underlying IO#readpartial method
+  # @return [String] The read data
+  # @raise [EOFError] If at end of stream
+  # @see IO#readpartial
+  # @since 2.1.0
+  def readpartial(*a)
+    super(*a).tap { |data| notify_read(data) }
+  end
+
+  # Reads at most a number of bytes without blocking.
+  #
+  # @param a [Array] Arguments to pass to the underlying IO#read_nonblock method
+  # @param kwargs [Hash] Keyword arguments to pass on, such as `exception: false`
+  # @return [String, Symbol, nil] The read data, or `:wait_readable` with `exception: false`
+  # @see IO#read_nonblock
+  # @since 2.1.0
+  def read_nonblock(*a, **kwargs)
+    super(*a, **kwargs).tap { |data| notify_read(data) }
+  end
+
+  # Reads bytes with a low-level read, bypassing buffering.
+  #
+  # @param a [Array] Arguments to pass to the underlying IO#sysread method
+  # @return [String] The read data
+  # @raise [EOFError] If at end of stream
+  # @see IO#sysread
+  # @since 2.1.0
+  def sysread(*a)
+    super(*a).tap { |data| notify_read(data) }
+  end
+
   # Reads a specific number of bytes from the IO stream.
-  # 
+  #
   # @param a [Array] Arguments to pass to the underlying IO#readbytes method
   # @return [String] The read bytes
   # @see IO#readbytes
   def readbytes(*a)
-    super(*a).tap { notify_read }
+    super(*a).tap { |data| notify_read(data) }
+  end
+
+  # Reads a single byte from the IO stream.
+  #
+  # @return [Integer] The next byte
+  # @raise [EOFError] If at end of stream
+  # @see IO#readbyte
+  # @since 2.1.0
+  def readbyte
+    super.tap { |b| notify_read(b) }
   end
-  
+
   # Reads a single character from the IO stream.
-  # 
+  #
   # @return [String] The next character
   # @raise [EOFError] If at end of stream
   # @see IO#readchar
   def readchar
-    super.tap { notify_read }
+    super.tap { |c| notify_read(c) }
   end
-  
+
   # Reads a line from the IO stream.
-  # 
+  #
   # @param a [Array] Arguments to pass to the underlying IO#readline method
+  # @param kwargs [Hash] Keyword arguments to pass on, such as `chomp: true`
   # @return [String] The next line
   # @raise [EOFError] If at end of stream
   # @see IO#readline
-  def readline(*a)
-    super(*a).tap { notify_read }
+  def readline(*a, **kwargs)
+    super(*a, **kwargs).tap { |line| notify_read(line, chomped: kwargs[:chomp]) }
   end
-  
+
   # Reads all lines from the IO stream.
-  # 
+  #
   # @param a [Array] Arguments to pass to the underlying IO#readlines method
+  # @param kwargs [Hash] Keyword arguments to pass on, such as `chomp: true`
   # @return [Array<String>] Array of lines
   # @see IO#readlines
-  def readlines(*a)
-    super(*a).tap { notify_read }
+  def readlines(*a, **kwargs)
+    super(*a, **kwargs).tap { |lines| notify_read(lines, chomped: kwargs[:chomp]) }
+  end
+
+  # Pushes a character back onto the stream. Not a read, so it is not reported - but on a stream
+  # without a position it is taken off the bytes read, so it is not counted twice.
+  #
+  # @param c [String, Integer] The character to push back
+  # @return [nil]
+  # @see IO#ungetc
+  # @since 2.1.0
+  def ungetc(c)
+    super(c).tap { unread(c) }
+  end
+
+  # Pushes a byte (or bytes) back onto the stream, see {#ungetc}.
+  #
+  # @param b [String, Integer] The byte or bytes to push back
+  # @return [nil]
+  # @see IO#ungetbyte
+  # @since 2.1.0
+  def ungetbyte(b)
+    super(b).tap { unread(b) }
+  end
+
+  # Conversions the wrapper does not pass on. Given `to_path`, IO.copy_stream opens the file by
+  # name itself, and given `to_io` (IO.select and the like too) it reads the wrapped IO directly
+  # - past the wrapper either way, with nothing reported. Without them IO.copy_stream reads
+  # through {#readpartial}. To get at the wrapped IO, use `__getobj__`.
+  #
+  # @since 2.1.0
+  WITHHELD = [:to_io, :to_path].freeze
+
+  def respond_to_missing?(name, include_private = false)
+    !WITHHELD.include?(name) && super
   end
-  
+
+  # Keyword arguments reach the wrapped IO through here, as they do in Delegator's own
+  ruby2_keywords def method_missing(name, *args, &blk)
+    raise NoMethodError.new("ProgressiveIO does not hand out the IO it wraps, so that reads go through it - use __getobj__", name) if WITHHELD.include?(name)
+    super
+  end
+
   # Seeks to a position in the IO stream.
-  # 
+  #
   # @param a [Array] Arguments to pass to the underlying IO#seek method
   # @return [Integer] The new position
   # @see IO#seek
   def seek(*a)
     super(*a)
   end
-  
-# def ungetc(*a)
-#   super(*a).tap { notify_read }
-# end 
-  
+
   # Sets the position in the IO stream.
-  # 
+  #
   # @param p [Integer] The new position
   # @return [Integer] The new position
   # @see IO#pos=
   def pos=(p)
     super(p).tap { notify_read }
   end
-  
+
   private
-    
-    # Calls the progress block with current position.
-    # This method is called whenever data is read from the IO stream.
-    # 
+
+    # Calls the progress block with the current position. A stream without one (a pipe, a
+    # socket) raises when asked for it, and from then on the bytes read so far stand in.
+    #
+    # @param data [String, Integer, Array, nil] What the read returned
+    # @param chomped [Boolean] Whether the read took line separators off what it returned, which
+    #   still came off the stream
     # @return [void]
-    def notify_read
-      @progress_block.call(pos) if @progress_block
+    def notify_read(data = nil, chomped: false)
+      position = positioned? ? pos : (@consumed += bytes_in(data, chomped))
+      @progress_block.call(position) if @progress_block
+    end
+
+    def positioned?
+      return @positioned unless @positioned.nil?
+      pos
+      @positioned = true
+    rescue Errno::ESPIPE, IOError
+      @positioned = false
+    end
+
+    def unread(data)
+      @consumed = [@consumed - bytes_in(data, false), 0].max unless positioned?
+    end
+
+    # With chomp, a line came off the stream with a separator that is not in it anymore. Which
+    # one is not known here; "\n" is the default and by far the likeliest, and the last line
+    # of a stream may have had none - so on a stream without a position, a chomped count can
+    # be a byte off per line, and the last one high by one
+    def bytes_in(data, chomped)
+      case data
+      when String then data.bytesize + (chomped ? 1 : 0)
+      when Integer then 1
+      when Array then data.sum { |item| bytes_in(item, chomped) }
+      else 0
+      end
+    end
+
+    def codepoint_string(codepoint)
+      codepoint.chr(external_encoding || Encoding::UTF_8)
+    rescue RangeError, EncodingError, NoMethodError
+      "?"
     end
 end

data/test/test_progressive_io.rb

@@ -3,6 +3,7 @@ require_relative "../lib/progressive_io"
 require "flexmock"
 require "flexmock/minitest"
 require "stringio"
+require "tempfile"
 
 class TestProgressiveIO < Minitest::Test
   
@@ -192,12 +193,7 @@ class TestProgressiveIO < Minitest::Test
     io.progress_block = lambda do | offset |
       assert_equal 1, offset
     end
-    
-    if RUBY_VERSION < "1.9"
-      assert_equal 49, io.getc
-    else
-      assert_equal "1", io.getc
-    end
+    assert_equal "1", io.readchar
   end
   
 
@@ -256,12 +252,13 @@ class TestProgressiveIO < Minitest::Test
     assert_equal [[22]], m
   end
   
-  def test_seek
-    io = e("Mary\nHad\nA little\nLamb")
-    io.progress_block = lambda do | offset |
-      assert_equal 6, offset
-    end
+  def test_seek_is_not_a_read
+    io, m = e("Mary\nHad\nA little\nLamb"), []
+    io.progress_block = lambda { |offset| m << offset }
     io.seek(6)
+    assert_empty m
+    io.read(2)
+    assert_equal [8], m
   end
   
 #  def test_ungetc
@@ -276,6 +273,151 @@ class TestProgressiveIO < Minitest::Test
 #    assert_equal [[1], [0]], m
 #  end
   
+  def reported(io)
+    [].tap { |m| io.progress_block = lambda { |offset| m << offset } }
+  end
+
+  def test_readpartial
+    io = e("Mary\nHad\nA little\nLamb")
+    m = reported(io)
+    assert_equal "Mary", io.readpartial(4)
+    assert_equal [4], m
+  end
+
+  def test_read_nonblock
+    io = e("Mary\nHad\nA little\nLamb")
+    m = reported(io)
+    assert_equal "Mary", io.read_nonblock(4)
+    assert_equal "\nHad", io.read_nonblock(4, exception: false)
+    assert_equal [4, 8], m
+  end
+
+  def test_sysread
+    io = e("Mary\nHad\nA little\nLamb")
+    m = reported(io)
+    assert_equal "Mary", io.sysread(4)
+    assert_equal [4], m
+  end
+
+  def test_getbyte_and_readbyte
+    io = e("123")
+    m = reported(io)
+    assert_equal 49, io.getbyte
+    assert_equal 50, io.readbyte
+    assert_equal [1, 2], m
+  end
+
+  def test_each_char
+    io = e("abc")
+    m = reported(io)
+    assert_equal %w[a b c], io.each_char.to_a
+    assert_equal [1, 2, 3], m
+  end
+
+  def test_each_codepoint
+    io = e("ab")
+    m = reported(io)
+    assert_equal [97, 98], io.each_codepoint.to_a
+    assert_equal [1, 2], m
+  end
+
+  # IO.copy_stream reads anything that is not an IO with readpartial
+  def test_copy_stream_is_reported
+    io = e("Mary\nHad\nA little\nLamb")
+    m = reported(io)
+    out = StringIO.new
+    IO.copy_stream(io, out)
+    assert_equal "Mary\nHad\nA little\nLamb", out.string
+    assert_equal 22, m.last
+  end
+
+  # A real IO would be handed to IO.copy_stream through to_io and read past the wrapper
+  def test_copy_stream_from_a_file_is_reported
+    Tempfile.create("progressive") do |f|
+      f.write("x" * 100_000)
+      f.flush
+      io = ProgressiveIO.new(File.open(f.path))
+      m = reported(io)
+      IO.copy_stream(io, StringIO.new)
+      assert_equal 100_000, m.last
+      refute io.respond_to?(:to_io)
+      refute io.respond_to?(:to_path)
+      assert_raises(NoMethodError) { io.to_io }
+      assert_kind_of File, io.__getobj__
+      io.__getobj__.close
+    end
+  end
+
+  def test_keyword_arguments_are_passed_on
+    io = e("Mary\nHad\nA little\nLamb")
+    m = reported(io)
+    assert_equal "Mary", io.gets(chomp: true)
+    assert_equal "Had", io.readline(chomp: true)
+    assert_equal ["A little", "Lamb"], io.readlines(chomp: true)
+    assert_equal [5, 9, 22], m
+
+    assert_equal ["Mary", "Had"], e("Mary\nHad\n").each_line(chomp: true).to_a
+    lines = []
+    e("Mary\nHad\n").each(chomp: true) { |line| lines << line }
+    assert_equal ["Mary", "Had"], lines
+  end
+
+  # A pipe or a socket has no position to report, so what has been read so far stands in for it
+  def test_streams_without_a_position_report_the_bytes_read
+    r, w = IO.pipe
+    w.write("Mary\nHad\nA little\nLamb")
+    w.close
+    io = ProgressiveIO.new(r)
+    m = reported(io)
+    assert_equal "Mary\n", io.gets
+    assert_equal "Had", io.read(3)
+    assert_equal "\n".ord, io.getbyte
+    assert_equal ["A little\n", "Lamb"], io.each_line.to_a
+    assert_equal [5, 8, 9, 18, 22], m
+  ensure
+    r.close if r
+  end
+
+  def test_bytes_pushed_back_into_a_stream_are_not_counted_twice
+    r, w = IO.pipe
+    w.write("Mary")
+    w.close
+    io = ProgressiveIO.new(r)
+    m = reported(io)
+    io.getc
+    io.ungetc("M")
+    assert_equal "Mary", io.read
+    assert_equal [1, 4], m
+  ensure
+    r.close if r
+  end
+
+  def test_copy_stream_from_a_pipe
+    r, w = IO.pipe
+    # More than a pipe holds, so it has to be written while it is read
+    writer = Thread.new { w.write("x" * 200_000); w.close }
+    io = ProgressiveIO.new(r)
+    m = reported(io)
+    IO.copy_stream(io, StringIO.new)
+    writer.join
+    assert_equal 200_000, m.last
+  ensure
+    r.close if r
+  end
+
+  def test_counts_reads_made_before_a_block_was_set
+    r, w = IO.pipe
+    w.write("Mary\nHad\n")
+    w.close
+    io = ProgressiveIO.new(r)
+    io.gets
+    m = reported(io)
+    io.gets
+    assert_equal [9], m
+  ensure
+    r.close if r
+  end
+
   def test_poseq
     io = e("Mary\nHad\nA little\nLamb")
     m = []

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: progressive_io
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Julik Tarkhanov
 bindir: bin
 cert_chain: []
-date: 2026-01-13 00:00:00.000000000 Z
+date: 2026-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -77,14 +77,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.6.2
 specification_version: 4
 summary: An IO wrapper that sends reports on the offset to a callback, on each read
   operation