progressive_io 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b644b242893003aa43e9f2c9ec382abc77ed6f08aef0acf13612fd8c01af6109
-  data.tar.gz: 9ceb2436e366cb6cc823fd1e1600a07d99f7ea3aa07ca299647050b410eab9e7
+  metadata.gz: e46f28055cb41f75b5a00b863d1771580ec7e610dd09d5360574e123c3b99867
+  data.tar.gz: b9ff8b9bf2724da050eb49933eac10c9d35953c30abd823fcc0482823a27a3a8
 SHA512:
-  metadata.gz: 800ce4c7128151cdf980f61fb50e2aa7c4811f0bad753535ee438fc2925b3d84018a176f633a18d27783af158dc8667b18623261ab8cccc460364b50f5958cae
-  data.tar.gz: 7cf60a1881e77bd39f2bf0dcff6cb9252c72130a24f1daaf2ede3fa62b9c90239a5d2d6a01f9d838b8f4ed79114e8811619c4f8955969a200b1e0e52152e4013
+  metadata.gz: e9c3bdfaf294545502b5dcde2381f67c4d343df02c64d9b56d290877f13619d283288a64517af7e5c5aa7f7359db6a0606684f693c0b8cdec9c32abfd2d27a43
+  data.tar.gz: 14fbce5195814ef1c583c664f8550b664e60d2d46a1465ef7ced873bd980247897fea75652f36444c4ff5511c67ba8be64dcd25644a310f907cd80d9f68ba236

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.0.2
+
+* Fix `each_line` to return an Enumerator that properly references `:each_line` method
+  when called without a block. Previously, `each_line` was an alias of `each`, causing
+  the returned Enumerator to reference `:each` instead of `:each_line`.
+* Change `each` and `each_line` to accept variadic arguments (`*args`) for proper
+  forwarding of separator and limit parameters.
+
+## 2.0.1
+
+* Revert back to using SimpleDelegator - it's just easier.
+
 ## 2.0.0
 
 * Added comprehensive documentation with examples

data/lib/progressive_io.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+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,
@@ -24,9 +26,9 @@
 #   content = progress_io.read
 # 
 # @since 2.0.0
-class ProgressiveIO
+class ProgressiveIO < SimpleDelegator
   # The version of the ProgressiveIO library
-  VERSION = '2.0.0'
+  VERSION = '2.0.2'
   
   # @return [Proc, nil] The progress callback block that will be called when data is read
   #   The block receives one parameter: current position
@@ -46,28 +48,57 @@ class ProgressiveIO
   #     puts "Read #{pos} bytes"
   #   end
   def initialize(with_io, &blk)
-    @io = with_io
+    super(with_io)
     @progress_block = blk.to_proc if blk
   end
   
   # Iterates over the IO stream line by line, calling the progress block for each line.
   # 
-  # @param sep_string [String] The line separator (defaults to $/)
+  # @param args [Array] Arguments to pass to the underlying IO#each method (separator and/or limit)
   # @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|
+  #   progress_io.each do |line|
   #     puts "Processing: #{line.chomp}"
   #   end
-  def each(sep_string = $/, &blk)
+  # 
+  # @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?
+    
     # Report offset at each call of the iterator
-    @io.each(sep_string) do | line |
+    super(*args) do |line|
       yield(line).tap { notify_read }
     end
   end
-  alias_method :each_line, :each
+  
+  # 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)
+  # @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)
+  end
   
   # Iterates over the IO stream byte by byte, calling the progress block for each byte.
   # 
@@ -79,9 +110,16 @@ class ProgressiveIO
   #   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
-    @io.each_byte { |b| yield(b).tap { notify_read } }
+    super { |b| yield(b).tap { notify_read } }
   end
   
   # Reads a single character from the IO stream.
@@ -89,7 +127,7 @@ class ProgressiveIO
   # @return [String, nil] The next character or nil if at end of stream
   # @see IO#getc
   def getc
-    inner(:getc)
+    super.tap { notify_read }
   end
   
   # Reads a line from the IO stream.
@@ -98,7 +136,7 @@ class ProgressiveIO
   # @return [String, nil] The next line or nil if at end of stream
   # @see IO#gets
   def gets(*args)
-    inner(:gets, *args)
+    super(*args).tap { notify_read }
   end
   
   # Reads data from the IO stream.
@@ -107,7 +145,7 @@ class ProgressiveIO
   # @return [String, nil] The read data or nil if at end of stream
   # @see IO#read
   def read(*a)
-    inner(:read, *a)
+    super(*a).tap { notify_read }
   end
   
   # Reads a specific number of bytes from the IO stream.
@@ -116,7 +154,7 @@ class ProgressiveIO
   # @return [String] The read bytes
   # @see IO#readbytes
   def readbytes(*a)
-    inner(:readbytes, *a)
+    super(*a).tap { notify_read }
   end
   
   # Reads a single character from the IO stream.
@@ -125,7 +163,7 @@ class ProgressiveIO
   # @raise [EOFError] If at end of stream
   # @see IO#readchar
   def readchar
-    inner(:readchar)
+    super.tap { notify_read }
   end
   
   # Reads a line from the IO stream.
@@ -135,7 +173,7 @@ class ProgressiveIO
   # @raise [EOFError] If at end of stream
   # @see IO#readline
   def readline(*a)
-    inner(:readline, *a)
+    super(*a).tap { notify_read }
   end
   
   # Reads all lines from the IO stream.
@@ -144,7 +182,7 @@ class ProgressiveIO
   # @return [Array<String>] Array of lines
   # @see IO#readlines
   def readlines(*a)
-    inner(:readlines, *a)
+    super(*a).tap { notify_read }
   end
   
   # Seeks to a position in the IO stream.
@@ -153,11 +191,11 @@ class ProgressiveIO
   # @return [Integer] The new position
   # @see IO#seek
   def seek(*a)
-    inner(:seek, *a)
+    super(*a)
   end
   
 # def ungetc(*a)
-#   inner(:ungetc, a)
+#   super(*a).tap { notify_read }
 # end 
   
   # Sets the position in the IO stream.
@@ -166,31 +204,16 @@ class ProgressiveIO
   # @return [Integer] The new position
   # @see IO#pos=
   def pos=(p)
-    inner(:pos=, p)
+    super(p).tap { notify_read }
   end
   
   private
     
-    # @return [IO] The wrapped IO object
-    def io
-      @io
-    end
-    
-    # Delegates method calls to the wrapped IO object and calls the progress block.
-    # 
-    # @param m [Symbol] The method name to call
-    # @param args [Array] Arguments to pass to the method
-    # @return [Object] The result of the method call
-    def inner(m, *args)
-      r = @io.respond_to?(:public_send) ? @io.public_send(m, *args) : @io.send(m, *args)
-      r.tap { notify_read }
-    end
-    
     # Calls the progress block with current position.
     # This method is called whenever data is read from the IO stream.
     # 
     # @return [void]
     def notify_read
-      @progress_block.call(@io.pos) if @progress_block
+      @progress_block.call(pos) if @progress_block
     end
 end

data/test/test_progressive_io.rb

@@ -29,6 +29,73 @@ class TestProgressiveIO < Minitest::Test
     assert_equal [[5], [9], [18], [22]], messages
   end
   
+  def test_each_returns_enumerator_without_block
+    io, messages = e("Mary\nHad\nA little\nLamb"), []
+    
+    io.progress_block = lambda do | offset |
+      messages.push([offset])
+    end
+    
+    enum = io.each
+    assert_kind_of Enumerator, enum
+    
+    # Enumerator should yield lines and still trigger progress callbacks
+    lines = enum.to_a
+    assert_equal ["Mary\n", "Had\n", "A little\n", "Lamb"], lines
+    assert_equal [[5], [9], [18], [22]], messages
+  end
+  
+  def test_each_line_returns_enumerator_without_block
+    io, messages = e("Mary\nHad\nA little\nLamb"), []
+    
+    io.progress_block = lambda do | offset |
+      messages.push([offset])
+    end
+    
+    enum = io.each_line
+    assert_kind_of Enumerator, enum
+    
+    # Enumerator should yield lines and still trigger progress callbacks
+    lines = enum.to_a
+    assert_equal ["Mary\n", "Had\n", "A little\n", "Lamb"], lines
+    assert_equal [[5], [9], [18], [22]], messages
+  end
+  
+  def test_each_enumerator_with_custom_separator
+    io, messages = e("Mary|Had|A little|Lamb"), []
+    
+    io.progress_block = lambda do | offset |
+      messages.push([offset])
+    end
+    
+    enum = io.each("|")
+    assert_kind_of Enumerator, enum
+    
+    lines = enum.to_a
+    assert_equal ["Mary|", "Had|", "A little|", "Lamb"], lines
+    assert_equal [[5], [9], [18], [22]], messages
+  end
+  
+  def test_each_enumerator_chainable
+    io = e("Mary\nHad\nA little\nLamb")
+    
+    # Should be chainable with Enumerator methods like with_index
+    result = io.each.with_index.map { |line, idx| [idx, line.chomp] }
+    assert_equal [[0, "Mary"], [1, "Had"], [2, "A little"], [3, "Lamb"]], result
+  end
+  
+  def test_each_line_enumerator_references_each_line_method
+    io = e("Mary\nHad\nLamb")
+    
+    # The enumerator returned by each_line should reference :each_line, not :each
+    # This is important for proper Enumerator behavior and introspection
+    each_enum = io.each
+    each_line_enum = io.each_line
+    
+    assert_match(/:each\b/, each_enum.inspect, "each enumerator should reference :each method")
+    assert_match(/:each_line\b/, each_line_enum.inspect, "each_line enumerator should reference :each_line method")
+  end
+  
   def test_each_byte
     io, messages = e("123"), []
     
@@ -42,6 +109,30 @@ class TestProgressiveIO < Minitest::Test
     assert_equal [[1], [2], [3]], messages
   end
   
+  def test_each_byte_returns_enumerator_without_block
+    io, messages = e("123"), []
+    
+    io.progress_block = lambda do | offset |
+      messages.push([offset])
+    end
+    
+    enum = io.each_byte
+    assert_kind_of Enumerator, enum
+    
+    # Enumerator should yield bytes and still trigger progress callbacks
+    bytes = enum.to_a
+    assert_equal [49, 50, 51], bytes
+    assert_equal [[1], [2], [3]], messages
+  end
+  
+  def test_each_byte_enumerator_chainable
+    io = e("123")
+    
+    # Should be chainable with Enumerator methods like with_index
+    result = io.each_byte.with_index.map { |byte, idx| [idx, byte] }
+    assert_equal [[0, 49], [1, 50], [2, 51]], result
+  end
+  
   def test_getc
     io = e("123")
     io.progress_block = lambda do | offset |

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: progressive_io
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Julik Tarkhanov
 bindir: bin
 cert_chain: []
-date: 2025-08-01 00:00:00.000000000 Z
+date: 2026-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake