angry_io 0.4.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efd2cce37a69f805e637ea406088049b150bb0ff9192a7423100add8b7a29342
-  data.tar.gz: 4e25659b95836fc83544b295cf40b6428d094cf194356ff1e4e0c0b8e7c1ad42
+  metadata.gz: 9b3f6e7d3135cb218b85c49be54b4be8f023d3349d73ad3caf225addcf161fbe
+  data.tar.gz: b7e58a351af2597e9cf33598f8e08c70428384da5ce125d24f4f7ac86dc6cb54
 SHA512:
-  metadata.gz: 72682994c9e8647d1405a46aa15366c377325f31396767f6f6efe0ef6e6722f875bdce839a0094c04db309e39cb691a05d3daa43d5b4aeff2372430f1e69cee1
-  data.tar.gz: 51ee62f1212076d50984ed31c221760464fbd2f15990abd8f4c241fd4294bcc259bffa5b9c46ce54942ab6a5b178582272cd9c09de08dae7fa67baa874bf7e0b
+  metadata.gz: bc6d5b2543aa8e10b3eef820ce422d3df46fa80b970d87de294d7266bcfc2ca0124cee0fc365a38c35029248f6cbb3daa4b0ad1a943e3295ec08521b3ac56cc1
+  data.tar.gz: 66448faebe489ae41a5a3f031339e646738cea271c4e8cc9764fb022dd469c0960baa8990a3de9c2ab72c93a391d9cf89ab8f078da28c8d3b4c31aad666410da

data/CHANGELOG.md

@@ -1,22 +1,13 @@
 ## [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.
-- Remove the configurable `opt_out_metadata` field; the RSpec opt-out metadata is now always `:i_absolutely_need_to_write_to_stdout`.
-- Adapters no longer swallow `LoadError` when their framework is missing; requiring an adapter now hard-requires its framework.
-
-## [0.1.0] - 2026-09-04
-
-- Initial release
+## [0.10.0] - 2026-09-18
+
+- AngryIO guards the real `STDOUT`/`STDERR` objects during tests — a write goes through to the stream and then raises `IOError`, so accidental output fails loudly and the offending line is visible in the test output right before the failure. Because the guard lives on the stream objects themselves, code holding earlier references (e.g. `Logger.new($stdout)` at boot) cannot bypass it; `Kernel#warn` and `Warning.warn` are intercepted at the source, since they write to stderr without dispatching to `$stderr#write`.
+- Self-registering adapters for Minitest and RSpec arm the guard around each test, with an opt-out per test class / example via `i_absolutely_need_to_write_to_stdout`.
+- `AngryIO.enabled` is a callable gating enforcement (default `-> { true }`), invoked once per test — e.g. `-> { ENV["CI"] == "true" }` to enforce on CI while leaving local debuggers usable.
+- Known limits: the arming flag is thread-local, so writes from threads spawned mid-test are not guarded, and rebinding `$stdout` to another IO bypasses the guard.
+- Zero-byte writes (e.g. `$stderr.print("")`) emit nothing and are allowed; anything that would produce output raises. `warn("")` still raises: `warn` appends a newline per message, so an empty message is not a zero-byte write.
+- Minitest's `capture_subprocess_io` and RSpec's `to_stdout_from_any_process` / `to_stderr_from_any_process` matchers work alongside AngryIO: they reopen the streams onto Tempfiles so subprocesses inherit the file descriptors, and the adapters run them under the new `AngryIO.disarmed` so the block's Ruby-level writes are captured instead of raising. `capture_io`, `assert_output`, and `assert_silent` rebind the globals to unguarded StringIOs and already worked.
+- Reopening a guarded stream (e.g. `$stdout.reopen(File::NULL)` after a fork) is treated as a deliberate redirect of the process's output: it goes through on the real IO and releases that stream from the guard for the rest of the test. A failed reopen raises before releasing, so the guard stays in place.
+- ActiveSupport's `capture`, `quietly`, and `silence_stream` (from `ActiveSupport::Testing::Stream`) work alongside AngryIO, disarmed like the other capture helpers.
+- A guarded write that raises flushes the stream first, so the offending line really does appear right before the failure even when the stream is block-buffered (Ruby buffers non-TTY stdout, e.g. on CI; Minitest sets `$stdout.sync = true` but RSpec leaves it false). While armed, `syswrite` and `write_nonblock` also flush before writing, so buffered output (e.g. the test runner's progress dots, printed while the guard is unarmed) goes out in order instead of tripping Ruby's `syswrite for buffered IO` warning, which `WarningGuard` would otherwise turn into a raise against an innocent write.

data/README.md

@@ -1,8 +1,8 @@
-# AngryIo
+# AngryIO
 
 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.
+AngryIO guards the real `$stdout` and `$stderr` during your test suite: a write goes through to the stream and then immediately _raises_, so accidental output fails loudly instead of quietly cluttering your output — and the offending line is right there in your test output, next to the failure, making it easy to find what printed. Because the guard lives on the stream objects themselves (not on the globals), code that captured a reference earlier — e.g. `Logger.new($stdout)` at boot — can't bypass it. AngryIO ships self-registering adapters for both RSpec and Minitest, gated by a configurable `enabled` callable.
 
 ## Installation
 
@@ -29,21 +29,21 @@ Depending on your test framework, you should require either `angry_io/rspec` or
 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:
+By default, AngryIO is always on, and every test that writes to `$stdout` or `$stderr` now prints the offending output and then raises:
 
 ```
-IOError: AngryIo::Stream is not writable: "your output here"
+your output here
+IOError: AngryIO: a test wrote to $stdout: "your output here"
 ```
 
 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:
+If you want to allow test output in some environments but not in others — e.g., fail on CI, but allow output when testing locally so REPL debuggers like `binding.irb` or `pry` work — set the `enabled` predicate:
 
 ```ruby
-# On by default; turn it off in environments where you'll allow real output.
-AngryIo.configure do |config|
-  config.enabled = -> { ENV["CI"] == "true" }
-end
+# On by default; turn it off in environments where you'll allow real output
+# (e.g. locally, so a debugger can write to stdout without raising).
+AngryIO.enabled = -> { ENV["CI"] == "true" }
 ```
 
 ### Opting out
@@ -83,15 +83,15 @@ end
 
 ## Configuration
 
-`AngryIo.configure` yields a config struct with one field:
-
-| Field              | Default                                 | Description                                                                                                           |
-| ---                | ---                                     | ---                                                                                                                   |
-| `enabled`          | `-> { true }`                           | A callable returning whether AngryIo is active. Invoked once per test, so it can read env vars or feature flags live. |
+`AngryIO.enabled` is a callable returning whether AngryIO is active. It defaults to `-> { true }` and is invoked once per test, so it can read env vars or feature flags live — e.g. `-> { ENV["CI"] == "true" }` to enforce on CI while leaving local debuggers usable.
 
 ## How it works
 
-`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`.
+At load time, AngryIO prepends a small guard module onto the `STDOUT` and `STDERR` objects, overriding their write methods. Around each test, the adapter arms the guard via a thread-local flag, and disarms it in an `ensure`. When armed, a write passes through to the real stream and then raises an `IOError`; zero-byte writes (e.g. `$stderr.print("")`) emit nothing and are allowed.
+
+Guarding the stream objects — rather than swapping the `$stdout`/`$stderr` globals — means anything holding a reference to the real streams (like a `Logger.new($stdout)` from boot time) is guarded too. `Kernel#warn` and `Warning.warn` write to stderr at C level without dispatching to `$stderr#write`, so AngryIO intercepts them at the source as well. Helpers that capture output on purpose keep working: `capture_io` rebinds the globals to unguarded `StringIO`s, and the adapters disarm the guard around `capture_subprocess_io`, RSpec's `to_*_from_any_process` matchers, and ActiveSupport's `capture`/`silence_stream`, which reopen the streams onto Tempfiles. Reopening a guarded stream yourself (e.g. `$stdout.reopen(File::NULL)` after a fork) is treated as a deliberate redirect: it goes through and releases that stream from the guard for the rest of the test.
+
+Two limits to be aware of: the arming flag is thread-local, so writes from threads spawned mid-test are not guarded; and rebinding `$stdout` to another IO bypasses the guard (we can't guard an object we've never seen).
 
 ## Development
 
@@ -113,4 +113,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the AngryIo project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/bquorning/angry_io/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the AngryIO project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/bquorning/angry_io/blob/main/CODE_OF_CONDUCT.md).

data/lib/angry_io/minitest.rb

@@ -2,15 +2,15 @@
 
 require "angry_io"
 
-# Prepends an override of +Minitest::Test#run+ that swaps $stdout/$stderr to
-# AngryIo::Stream instances around each test. A test class opts out by calling
+# Prepends an override of +Minitest::Test#run+ that arms AngryIO's write-guard
+# on STDOUT/STDERR around each test. A test class opts out by calling
 # +i_absolutely_need_to_write_to_stdout!+ in its body. Force-loads Minitest so
 # registration works regardless of Bundler.require ordering.
-module AngryIo
+module AngryIO
   module Minitest
     module Adapter
       def run
-        AngryIo.around_streams(opted_out: self.class.i_absolutely_need_to_write_to_stdout?) { super }
+        AngryIO.around_streams(opted_out: self.class.i_absolutely_need_to_write_to_stdout?) { super }
       end
     end
 
@@ -25,12 +25,12 @@ module AngryIo
     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.
+    # subprocesses inherit the file descriptors — a deliberate redirect whose
+    # output is captured, not pollution. Disarm the guard for the duration of
+    # the capture.
     module CaptureSubprocessIo
       def capture_subprocess_io(&block)
-        AngryIo.with_real_streams { super }
+        AngryIO.disarmed { super }
       end
     end
 
@@ -38,10 +38,10 @@ module AngryIo
       ::Minitest::Test.extend(ClassMethods)
       ::Minitest::Test.prepend(Adapter)
       ::Minitest::Assertions.prepend(CaptureSubprocessIo)
-      AngryIo.hook_active_support_stream!
+      AngryIO.hook_active_support_stream!
     end
   end
 end
 
 require "minitest"
-AngryIo::Minitest.setup!
+AngryIO::Minitest.setup!

data/lib/angry_io/rspec.rb

@@ -2,32 +2,31 @@
 
 require "angry_io"
 
-# Registers an +around+ hook that swaps $stdout/$stderr to AngryIo::Stream
-# instances during each example, unless the example opts out via the
+# Registers an +around+ hook that arms AngryIO's write-guard on STDOUT/STDERR
+# during each example, unless the example opts out via the
 # +:i_absolutely_need_to_write_to_stdout+ metadata. Force-loads rspec-core so
 # registration works regardless of Bundler.require ordering.
-module AngryIo
+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...
+    # so subprocesses inherit the file descriptors. An example using these
+    # matchers captures output on purpose, so disarm the guard while the
+    # matcher grabs the stream...
     module FromAnyProcess
       def to_stdout_from_any_process
-        AngryIo.with_real_streams { super }
+        AngryIO.disarmed { super }
       end
 
       def to_stderr_from_any_process
-        AngryIo.with_real_streams { super }
+        AngryIO.disarmed { 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.
+    # are captured by the Tempfile instead of raising against the guard.
     module CaptureStreamToTempfile
       def capture(block)
-        AngryIo.with_real_streams { super }
+        AngryIO.disarmed { super }
       end
     end
 
@@ -36,17 +35,17 @@ module AngryIo
         config.around do |example|
           opt_out = example.metadata.key?(:i_absolutely_need_to_write_to_stdout) &&
             example.metadata[:i_absolutely_need_to_write_to_stdout]
-          AngryIo.around_streams(opted_out: opt_out) { example.run }
+          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!
+      AngryIO.hook_active_support_stream!
     end
   end
 end
 
 require "rspec/core"
 require "rspec/expectations"
-AngryIo::RSpec.setup!
+AngryIO::RSpec.setup!

data/lib/angry_io/version.rb

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

data/lib/angry_io.rb

@@ -1,178 +1,188 @@
 # frozen_string_literal: true
 
-require "stringio"
 require_relative "angry_io/version"
 
-module AngryIo
-  # An IO that raises when you write to it, so tests can't silently pollute
-  # 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(+"")
+module AngryIO
+  # Prepended to the STDOUT/STDERR singletons. While armed (a test is running
+  # under AngryIO.around_streams and hasn't opted out), a write goes through to
+  # the real stream and *then* raises IOError — the offending output appears in
+  # the test output right before the failure, so it's easy to see what printed.
+  # Guarding the real stream objects, instead of swapping the globals, means
+  # code that captured a reference earlier (e.g. `Logger.new($stdout)` at boot)
+  # can't bypass the guard.
+  module Guard
+    # IO#print, puts, printf and << all funnel through #write, so this one
+    # guard catches them.
+    def write(*strings)
+      result = super
+      AngryIO.check_output!(self, strings)
+      result
     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?
+    # syswrite and write_nonblock bypass #write, so they need their own guards.
+    # Both warn ("syswrite for buffered IO") when the stream has buffered
+    # output pending — and buffered output can be there without us knowing
+    # (e.g. the test runner's progress dots, printed between tests while the
+    # guard is unarmed). The WarningGuard would turn that warning into a raise
+    # against an innocent write, so flush first while armed: the pending output
+    # goes out in order, the buffer stays clean, and no warning fires.
+    def syswrite(string)
+      flush if AngryIO.armed?
+      result = super
+      AngryIO.check_output!(self, [string])
+      result
+    end
 
-        raise IOError, "AngryIo::Stream is not writable: #{string.to_s.inspect}"
-      end
-      super
+    def write_nonblock(string, **options)
+      flush if AngryIO.armed?
+      result = super
+      AngryIO.check_output!(self, [string])
+      result
     end
 
-    # StringIO#putc writes directly in C, bypassing #write. It always emits a
-    # byte, so it always refuses.
+    # putc writes directly in C, bypassing #write.
     def putc(char)
-      raise IOError, "AngryIo::Stream is not writable: #{char.inspect}"
+      result = super
+      AngryIO.check_output!(self, [char])
+      result
     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
+    # Reopening the stream (e.g. `$stdout.reopen(File::NULL)` after a fork) is
+    # a deliberate redirect of the process's output: let it through and release
+    # this stream from the guard for the rest of the test, so subsequent writes
+    # reach the reopened target instead of raising. A failed reopen raises
+    # before releasing, so the guard stays in place.
+    #
+    # `reopen(other_io)` also turns the receiver into a copy of the other IO,
+    # replacing its singleton class — which strips this very module off the
+    # stream. Re-prepend it afterwards so the guard survives; a no-op when the
+    # module is still present (e.g. after a path reopen).
+    def reopen(*args)
+      result = super
+      singleton_class.prepend(AngryIO::Guard)
+      AngryIO.release!(self) if AngryIO.armed?
+      result
+    end
+  end
+
+  # Kernel#warn writes to stderr at C level without dispatching to
+  # $stderr#write (when $stderr is a real IO), so it bypasses Guard. Intercept
+  # it at the source. warn always appends a newline per message, so even an
+  # empty message emits output; a message-less warn emits nothing.
+  module WarnGuard
+    def warn(*messages, **options)
+      result = super
+      AngryIO.check_output!($stderr, messages.map { |m| m.to_s.empty? ? "\n" : m })
+      result
+    end
+  end
+
+  # Warning.warn (deprecations and other Ruby-level warnings) is the same:
+  # it writes to stderr without dispatching to $stderr#write.
+  module WarningGuard
+    def warn(message, **options)
+      result = super
+      AngryIO.check_output!($stderr, [message])
+      result
     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.
+  # Tempfile and #silence_stream reopens onto IO::NULL — deliberate redirects
+  # whose block output is captured or silenced on purpose, not test pollution.
+  # Disarm the guard for the duration, the same way Minitest's
+  # capture_subprocess_io is handled.
   module ActiveSupportStreamCapture
     def capture(stream)
-      AngryIo.with_real_streams { super }
+      AngryIO.disarmed { 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) }
+      AngryIO.disarmed { super }
     end
 
     private :capture, :silence_stream
   end
 
-  Config = Struct.new(:enabled) do
-    def initialize
-      self.enabled = -> { true }
-    end
-  end
-
-  @config = Config.new
+  @enabled = -> { true }
 
   class << self
-    attr_reader :config
-
-    def configure
-      yield @config
-    end
+    attr_accessor :enabled
 
-    # Swap $stdout and $stderr to AngryIo::Stream instances around the given
-    # block, restoring them (and closing the buffers) in an ensure. No-ops when
-    # +opted_out+ is true or when +config.enabled+ returns false, so the block
-    # runs untouched.
+    # Arm the write-guard on STDOUT/STDERR around the given block, restoring
+    # the previous state in an ensure. No-ops when +opted_out+ is true or when
+    # +enabled+ returns false, so the block runs untouched.
     def around_streams(opted_out: false)
       return yield if opted_out
-      return yield unless config.enabled.call
+      return yield unless enabled.call
 
-      original_stdout = $stdout
-      original_stderr = $stderr
-      stdout_buffer = Stream.new
-      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])
+      previous_armed = Thread.current.thread_variable_get(:angry_io_armed)
+      previous_released = Thread.current.thread_variable_get(:angry_io_released)
+      Thread.current.thread_variable_set(:angry_io_armed, true)
+      Thread.current.thread_variable_set(:angry_io_released, [])
 
       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
+        Thread.current.thread_variable_set(:angry_io_armed, previous_armed)
+        Thread.current.thread_variable_set(:angry_io_released, previous_released)
       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)
+    # Run the block with the guard disarmed. Helpers like Minitest's
+    # capture_subprocess_io or ActiveSupport's capture need this: they redirect
+    # the streams on purpose, so the block's writes are captured, not errors.
+    def disarmed
+      previous = Thread.current.thread_variable_get(:angry_io_armed)
+      Thread.current.thread_variable_set(:angry_io_armed, false)
+      yield
+    ensure
+      Thread.current.thread_variable_set(:angry_io_armed, previous)
+    end
 
-      $stdout = real_stdout
-      $stderr = real_stderr
+    # Whether the write-guard is armed on the current thread. The flag is
+    # thread-local (not fiber-local), so captures running inside a Fiber —
+    # e.g. Enumerator-based code — see the same state as their test.
+    def armed?
+      Thread.current.thread_variable_get(:angry_io_armed) || false
+    end
 
-      begin
-        yield
-      ensure
-        $stdout = stdout_buffer
-        $stderr = stderr_buffer
-      end
+    # Release a stream from the guard for the rest of the surrounding test
+    # (see Guard#reopen).
+    def release!(io)
+      released = Thread.current.thread_variable_get(:angry_io_released)
+      released << io if released && !released.include?(io)
     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
+    # Called by Guard (and the warn intercepts) after a write has gone through
+    # to the real stream. Raises IOError if the guard is armed, the target is
+    # one of the guarded streams that hasn't been released, and the write would
+    # actually emit output (zero-byte writes are allowed). A $stdout/$stderr
+    # the user rebound to another object (e.g. capture_io's StringIO) is not
+    # guarded, so writes to it are fine.
+    # standard:disable Style/GlobalStdStream — we mean the real stream objects, not the globals
+    def check_output!(io, strings)
+      return unless armed?
+      return unless io.equal?(STDOUT) || io.equal?(STDERR)
+      return if Thread.current.thread_variable_get(:angry_io_released)&.include?(io)
+
+      offending = strings.map(&:to_s).reject(&:empty?)
+      return if offending.empty?
+
+      name = io.equal?(STDOUT) ? "$stdout" : "$stderr"
+      # Flush so the offending line really does appear right before the failure
+      # even when the stream is block-buffered ($stdout.sync == false, e.g. on
+      # CI or under RSpec) — and so the buffer is left empty, keeping a later
+      # syswrite from tripping Ruby's "syswrite for buffered IO" warning (which
+      # WarningGuard turns into a raise) in an innocent test.
+      io.flush
+      raise IOError, "AngryIO: a test wrote to #{name}:\n  #{offending.join}"
     end
+    # standard:enable Style/GlobalStdStream
 
     # 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.
+    # run with the guard disarmed (see ActiveSupportStreamCapture). No-ops when
+    # ActiveSupport isn't loaded.
     def hook_active_support_stream!
       require "active_support/testing/stream"
       ActiveSupport::Testing::Stream.prepend(ActiveSupportStreamCapture)
@@ -181,3 +191,11 @@ module AngryIo
     end
   end
 end
+
+# standard:disable Style/GlobalStdStream — guard the real stream objects, not the globals
+STDOUT.singleton_class.prepend(AngryIO::Guard)
+STDERR.singleton_class.prepend(AngryIO::Guard)
+# standard:enable Style/GlobalStdStream
+Kernel.prepend(AngryIO::WarnGuard)
+Kernel.singleton_class.prepend(AngryIO::WarnGuard) # warn is a module_function
+Warning.singleton_class.prepend(AngryIO::WarningGuard)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: angry_io
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -9,10 +9,10 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: AngryIo replaces $stdout/$stderr during tests with an IO that raises
-  on write, so accidental output fails loudly instead of cluttering CI logs. Ships
-  RSpec and Minitest adapters that self-register, gated by a configurable enabled
-  callable.
+description: 'AngryIO guards the real $stdout/$stderr during tests: a write goes through
+  to the stream and then raises, so accidental output fails loudly and the offending
+  line is visible in the test output. Ships RSpec and Minitest adapters that self-register,
+  gated by a configurable enabled callable.'
 email:
 - bquorning@zendesk.com
 executables: []
@@ -51,5 +51,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.20
 specification_version: 4
-summary: An IO that raises on write, to keep tests from polluting stdout/stderr.
+summary: 'Guards stdout/stderr during tests: writes go through, then raise.'
 test_files: []