angry_io 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e481e761566636d3cc9fcf965a2d5880a3b65e818cc1312c1c62897ccd6c16a1
-  data.tar.gz: 702fc8469bf85c8aec44fbfa861fcc86263b5bbb3bdb28b25338f26d3148caa7
+  metadata.gz: efd2cce37a69f805e637ea406088049b150bb0ff9192a7423100add8b7a29342
+  data.tar.gz: 4e25659b95836fc83544b295cf40b6428d094cf194356ff1e4e0c0b8e7c1ad42
 SHA512:
-  metadata.gz: a862f0a1adf1077e3b7c6a43192692d22086e72f0761f7bd7629e13fc7b23908e798308ba969482b78d411686f34edee159544a2f93840d1391a18728f240c0a
-  data.tar.gz: 2ed4b06091d5afb5a9449e5fd3acd649995a09ee2e73ca8f4bf68b9f3cd27bef67d91959b4c2b9f503b1eec0847ff7b268d502e5c071fa11e866c11103a6ac18
+  metadata.gz: 72682994c9e8647d1405a46aa15366c377325f31396767f6f6efe0ef6e6722f875bdce839a0094c04db309e39cb691a05d3daa43d5b4aeff2372430f1e69cee1
+  data.tar.gz: 51ee62f1212076d50984ed31c221760464fbd2f15990abd8f4c241fd4294bcc259bffa5b9c46ce54942ab6a5b178582272cd9c09de08dae7fa67baa874bf7e0b

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [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.
+- Minitest's `capture_subprocess_io` and RSpec's `to_stdout_from_any_process` / `to_stderr_from_any_process` matchers now work alongside AngryIo. These helpers reopen `$stdout`/`$stderr` onto Tempfiles so subprocesses inherit the file descriptors, which fails on the StringIO-based `AngryIo::Stream`; AngryIo now restores the real streams for their duration via a new `AngryIo.with_real_streams` helper.
+
 ## [0.2.0] - 2026-09-04
 
 - Remove the `angry_io/enable_for_ci_true` convenience require; require `angry_io/rspec` or `angry_io/minitest` directly instead.

data/README.md

@@ -1,6 +1,6 @@
 # AngryIo
 
-Friends don't let friends write tests or specs that outputs to stdout/stderr. When you look at your test output, you should only see green dots, right?
+Friends don't let friends write tests or specs that output to stdout/stderr. When you look at your test output, you should only see green dots, right?
 
 AngryIo replaces `$stdout` and `$stderr` during your test suite with an IO that _raises on write_, so accidental output fails loudly instead of quietly cluttering your output. It ships self-registering adapters for both RSpec and Minitest, gated by a configurable `enabled` callable.
 
@@ -32,10 +32,12 @@ require "angry_io/rspec"      # or "angry_io/minitest"
 By default, AngryIo is always on, and every test that writes to `$stdout` or `$stderr` now raises:
 
 ```
-IOError: not opened for writing
+IOError: AngryIo::Stream is not writable: "your output here"
 ```
 
-If you want to allow test output in some environments but not in others - e.g allow output when testing locally, but fail on CI - you can configure like this:
+Zero-byte writes (e.g. `$stderr.print("")`) emit nothing, so they are allowed.
+
+If you want to allow test output in some environments but not in others — e.g., allow output when testing locally, but fail on CI — you can configure like this:
 
 ```ruby
 # On by default; turn it off in environments where you'll allow real output.
@@ -66,9 +68,22 @@ class PrintTest < Minitest::Test
 end
 ```
 
+The same call works in Minitest's spec format, inside the `describe` block:
+
+```ruby
+# Minitest spec format — opt out a whole describe block
+describe "printing" do
+  i_absolutely_need_to_write_to_stdout!
+
+  it "prints" do
+    puts "ok"
+  end
+end
+```
+
 ## Configuration
 
-`AngryIo.configure` yields a config struct with two fields:
+`AngryIo.configure` yields a config struct with one field:
 
 | Field              | Default                                 | Description                                                                                                           |
 | ---                | ---                                     | ---                                                                                                                   |
@@ -76,7 +91,7 @@ end
 
 ## How it works
 
-`AngryIo::Stream` is a `StringIO` backed by a frozen empty string, which makes `StringIO` refuse writes with an `IOError`. Around each test, the adapter swaps `$stdout` and `$stderr` to fresh `AngryIo::Stream` instances and restores the originals (closing the buffers) in an `ensure`.
+`AngryIo::Stream` is a `StringIO` whose write methods raise an `IOError` when given anything but an empty string. Around each test, the adapter swaps `$stdout` and `$stderr` to fresh `AngryIo::Stream` instances and restores the originals (closing the buffers) in an `ensure`.
 
 ## Development
 

data/lib/angry_io/minitest.rb

@@ -24,10 +24,21 @@ module AngryIo
       end
     end
 
+    # capture_subprocess_io reopens $stdout/$stderr onto Tempfiles so
+    # subprocesses inherit the file descriptors, which fails on StringIO-based
+    # streams. A test calling it captures output on purpose, so restore the
+    # real streams for the duration of the capture.
+    module CaptureSubprocessIo
+      def capture_subprocess_io(&block)
+        AngryIo.with_real_streams { super }
+      end
+    end
+
     def self.setup!
-      test = ::Minitest::Test
-      test.extend(ClassMethods)
-      test.prepend(Adapter)
+      ::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

@@ -8,6 +8,29 @@ require "angry_io"
 # registration works regardless of Bundler.require ordering.
 module AngryIo
   module RSpec
+    # The to_*_from_any_process matchers reopen $stdout/$stderr onto Tempfiles
+    # so subprocesses inherit the file descriptors, which fails on
+    # StringIO-based streams. An example using these matchers captures output
+    # on purpose, so restore the real streams while the matcher grabs the
+    # stream...
+    module FromAnyProcess
+      def to_stdout_from_any_process
+        AngryIo.with_real_streams { super }
+      end
+
+      def to_stderr_from_any_process
+        AngryIo.with_real_streams { super }
+      end
+    end
+
+    # ...and while the block runs, so Ruby-level writes inside the expect block
+    # are captured by the Tempfile instead of raising against the Angry stream.
+    module CaptureStreamToTempfile
+      def capture(block)
+        AngryIo.with_real_streams { super }
+      end
+    end
+
     def self.setup!
       ::RSpec.configure do |config|
         config.around do |example|
@@ -16,9 +39,14 @@ module AngryIo
           AngryIo.around_streams(opted_out: opt_out) { example.run }
         end
       end
+
+      ::RSpec::Matchers::BuiltIn::Output.prepend(FromAnyProcess)
+      ::RSpec::Matchers::BuiltIn::CaptureStreamToTempfile.prepend(CaptureStreamToTempfile)
+      AngryIo.hook_active_support_stream!
     end
   end
 end
 
 require "rspec/core"
+require "rspec/expectations"
 AngryIo::RSpec.setup!

data/lib/angry_io/version.rb

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

data/lib/angry_io.rb

@@ -5,12 +5,84 @@ require_relative "angry_io/version"
 
 module AngryIo
   # An IO that raises when you write to it, so tests can't silently pollute
-  # stdout/stderr. Backed by a frozen empty string, which makes StringIO
-  # refuse writes with an IOError ("not opened for writing").
+  # stdout/stderr. Zero-byte writes like `$stderr.print("")` emit nothing and
+  # are allowed; anything that would produce output raises an IOError.
   class Stream < StringIO
     def initialize
-      super(-"")
+      super(+"")
     end
+
+    # StringIO's print, puts, printf, <<, syswrite and write_nonblock all
+    # funnel through #write, so this one guard catches them.
+    def write(*strings)
+      strings.each do |string|
+        next if string.to_s.empty?
+
+        raise IOError, "AngryIo::Stream is not writable: #{string.to_s.inspect}"
+      end
+      super
+    end
+
+    # StringIO#putc writes directly in C, bypassing #write. It always emits a
+    # byte, so it always refuses.
+    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
@@ -42,15 +114,70 @@ module AngryIo
       stderr_buffer = Stream.new
       $stdout = stdout_buffer
       $stderr = stderr_buffer
+      previous_swap = Thread.current.thread_variable_get(:angry_io_swap)
+      Thread.current.thread_variable_set(:angry_io_swap, [original_stdout, original_stderr, stdout_buffer, stderr_buffer])
 
       begin
         yield
       ensure
+        Thread.current.thread_variable_set(:angry_io_swap, previous_swap)
         $stdout = original_stdout
         $stderr = original_stderr
         stdout_buffer.close
         stderr_buffer.close
       end
     end
+
+    # Run the block with the pre-swap $stdout/$stderr restored, re-swapping the
+    # 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, 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
+
+      begin
+        yield
+      ensure
+        $stdout = stdout_buffer
+        $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.2.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: []