angry_io 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 597667423eb4ee7ad9daaf21e0ee59e86f361a07e37a5b6d7bdc03a89978ead6
-  data.tar.gz: df59a437ba441870cc0d6788748ea115d632b9c7770266a1ef901e4a966cb413
+  metadata.gz: efd2cce37a69f805e637ea406088049b150bb0ff9192a7423100add8b7a29342
+  data.tar.gz: 4e25659b95836fc83544b295cf40b6428d094cf194356ff1e4e0c0b8e7c1ad42
 SHA512:
-  metadata.gz: 44154fa02cb72e8cbf89c5c24b3a4996a4600b0e3d17c484a50222875ea1b7fdc9c830150a7b618cee54eb05ce6cdab82fb1bc67dcebc4b42d7facd4578a5429
-  data.tar.gz: '083c923145f4247d847613ba082f1f9d509fd7dd7cdb9bce34b5db89f722051e5ca07ef4057af6c111a63656fa3fdf8be19957dce330a1cdf98babbb2c80e046'
+  metadata.gz: 72682994c9e8647d1405a46aa15366c377325f31396767f6f6efe0ef6e6722f875bdce839a0094c04db309e39cb691a05d3daa43d5b4aeff2372430f1e69cee1
+  data.tar.gz: 51ee62f1212076d50984ed31c221760464fbd2f15990abd8f4c241fd4294bcc259bffa5b9c46ce54942ab6a5b178582272cd9c09de08dae7fa67baa874bf7e0b

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-09-15
+
+- Reopening `$stdout`/`$stderr` onto a real IO (e.g. `$stdout.reopen(File::NULL)`) no longer raises `TypeError` under `AngryIo::Stream`. `Stream#reopen` now delegates an IO argument to the original real stream it replaced (a `dup2` that survives the caller closing the other IO) and hands the global back so writes reach the reopened IO; non-IO arguments still defer to StringIO's own buffer reset. The new `AngryIo.real_stream_for` returns the real stream a swapped buffer replaced.
+- ActiveSupport's `capture` and `silence_stream` (from `ActiveSupport::Testing::Stream`) now work alongside AngryIo. They use the same reopen-onto-IO pattern as `capture_subprocess_io`, so AngryIo now runs them under `with_real_streams`, substituting the real stream for the StringIO buffer that `silence_stream` binds at call time.
+- `AngryIo.with_real_streams` is now reentrant: a nested call (e.g. ActiveSupport's `capture` wrapping `quietly`, whose nested `silence_stream` re-enters the helper) no longer swaps the globals back to the Angry buffers while the outer call still expects the real streams. It no-ops when the real streams are already current.
+
 ## [0.3.0] - 2026-09-06
 
 - Zero-byte writes (e.g. `$stderr.print("")`) no longer raise; `AngryIo::Stream` now raises only when a write would actually emit output. The error message changed from StringIO's `not opened for writing` to `AngryIo::Stream is not writable: ...`, which includes the offending output.

data/lib/angry_io/minitest.rb

@@ -38,6 +38,7 @@ module AngryIo
       ::Minitest::Test.extend(ClassMethods)
       ::Minitest::Test.prepend(Adapter)
       ::Minitest::Assertions.prepend(CaptureSubprocessIo)
+      AngryIo.hook_active_support_stream!
     end
   end
 end

data/lib/angry_io/rspec.rb

@@ -42,6 +42,7 @@ module AngryIo
 
       ::RSpec::Matchers::BuiltIn::Output.prepend(FromAnyProcess)
       ::RSpec::Matchers::BuiltIn::CaptureStreamToTempfile.prepend(CaptureStreamToTempfile)
+      AngryIo.hook_active_support_stream!
     end
   end
 end

data/lib/angry_io/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AngryIo
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/angry_io.rb

@@ -28,6 +28,61 @@ module AngryIo
     def putc(char)
       raise IOError, "AngryIo::Stream is not writable: #{char.inspect}"
     end
+
+    # `IO#reopen(io)` redirects a real $stdout/$stderr onto another IO (a
+    # socket, a File, etc.) so the process's output flows there. StringIO only
+    # accepts a String, so reopening onto an IO would raise
+    # `TypeError: can't convert IO into StringIO` — which breaks code that
+    # reopens the streams after a fork. Delegate to the original real stream we
+    # replaced (which dup2's the other IO's fd onto the stdout/stderr fd,
+    # surviving the caller later closing the other IO), then hand the global
+    # back so subsequent writes reach the reopened IO instead of this guard.
+    # Non-IO args defer to StringIO's own reopen (buffer reset).
+    def reopen(other = nil, *rest)
+      if other.is_a?(IO) && (swap = Thread.current.thread_variable_get(:angry_io_swap))
+        real_stdout, real_stderr, stdout_buffer, stderr_buffer = swap
+        if equal?(stdout_buffer)
+          real_stdout.reopen(other)
+          $stdout = real_stdout
+        elsif equal?(stderr_buffer)
+          real_stderr.reopen(other)
+          $stderr = real_stderr
+        else
+          # Not one of the swapped buffers (a standalone Stream someone assigned
+          # to $stdout outside the adapter): no original to delegate to, so match
+          # StringIO and raise TypeError instead of silently no-op'ing.
+          super
+        end
+        self
+      elsif other.nil? && rest.empty?
+        super() # StringIO#reopen() resets the buffer
+      else
+        super
+      end
+    end
+  end
+
+  # ActiveSupport::Testing::Stream#capture reopens $stdout/$stderr onto a
+  # Tempfile and later restores them via `reopen(dup)` — a dup2-then-restore
+  # pattern that only works on real IOs (Tempfile is a Delegator, and StringIO
+  # can't be reopened onto one). Restore the real streams for the duration of a
+  # capture/silence, the same way Minitest's capture_subprocess_io is handled.
+  module ActiveSupportStreamCapture
+    def capture(stream)
+      AngryIo.with_real_streams { super }
+    end
+
+    def silence_stream(stream)
+      # `stream` is bound at call time, so under AngryIo it's the StringIO
+      # buffer — which AS can't actually reopen onto IO::NULL (it just resets
+      # the buffer), leaking the block's writes to the real stream. Substitute
+      # the real stream it replaced so AS silences (and the block writes to) the
+      # real IO.
+      real = AngryIo.real_stream_for(stream)
+      AngryIo.with_real_streams { super(real || stream) }
+    end
+
+    private :capture, :silence_stream
   end
 
   Config = Struct.new(:enabled) do
@@ -77,12 +132,17 @@ module AngryIo
     # AngryIo::Stream buffers afterwards. Helpers like Minitest's
     # capture_subprocess_io need this: they reopen $stdout/$stderr onto
     # Tempfiles so subprocesses inherit the file descriptors, which only works
-    # on real IOs. No-ops when no swap is active.
+    # on real IOs. No-ops when no swap is active, or when the real streams are
+    # already current (a nested call inside another with_real_streams — e.g.
+    # ActiveSupport's `capture` wrapping `quietly` — so the inner ensure doesn't
+    # clobber the outer's swap-back).
     def with_real_streams
       swap = Thread.current.thread_variable_get(:angry_io_swap)
       return yield unless swap
 
       real_stdout, real_stderr, stdout_buffer, stderr_buffer = swap
+      return yield if $stdout.equal?(real_stdout) && $stderr.equal?(real_stderr)
+
       $stdout = real_stdout
       $stderr = real_stderr
 
@@ -93,5 +153,31 @@ module AngryIo
         $stderr = stderr_buffer
       end
     end
+
+    # If `stream` is one of the active swap's AngryIo::Stream buffers, return the
+    # real stream it replaced; otherwise nil. Used by
+    # ActiveSupportStreamCapture#silence_stream to redirect silencing onto the
+    # real IO instead of the StringIO buffer.
+    def real_stream_for(stream)
+      swap = Thread.current.thread_variable_get(:angry_io_swap)
+      return nil unless swap
+
+      real_stdout, real_stderr, stdout_buffer, stderr_buffer = swap
+      if stream.equal?(stdout_buffer)
+        real_stdout
+      elsif stream.equal?(stderr_buffer)
+        real_stderr
+      end
+    end
+
+    # Prepend hooks so ActiveSupport::Testing::Stream#capture / #silence_stream
+    # run with the real $stdout/$stderr restored (see ActiveSupportStreamCapture).
+    # No-ops when ActiveSupport isn't loaded.
+    def hook_active_support_stream!
+      require "active_support/testing/stream"
+      ActiveSupport::Testing::Stream.prepend(ActiveSupportStreamCapture)
+    rescue LoadError
+      # ActiveSupport isn't available; nothing to hook.
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: angry_io
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -49,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: An IO that raises on write, to keep tests from polluting stdout/stderr.
 test_files: []