angry_io 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 597667423eb4ee7ad9daaf21e0ee59e86f361a07e37a5b6d7bdc03a89978ead6
-  data.tar.gz: df59a437ba441870cc0d6788748ea115d632b9c7770266a1ef901e4a966cb413
+  metadata.gz: 89b93a80d709137ae29eb42cfda731bd4196ad40cfc4e56f2b3a12fc2961eee9
+  data.tar.gz: 49b1f5f622b6a1796013f0c370391a5e3941f6ffb67b8fb15b6b762470b8a093
 SHA512:
-  metadata.gz: 44154fa02cb72e8cbf89c5c24b3a4996a4600b0e3d17c484a50222875ea1b7fdc9c830150a7b618cee54eb05ce6cdab82fb1bc67dcebc4b42d7facd4578a5429
-  data.tar.gz: '083c923145f4247d847613ba082f1f9d509fd7dd7cdb9bce34b5db89f722051e5ca07ef4057af6c111a63656fa3fdf8be19957dce330a1cdf98babbb2c80e046'
+  metadata.gz: 80fbb90830d2836b63b73302b5a7f12dad52a8a05353290cc286b5493cd75446bd343f2c660f373716d0beb6e2b130014502751213fb22fb37e36c8d6d193650
+  data.tar.gz: 29f6e481c7e4dde2c6e45db4ae6c03d6621e496673565144b79149057e3d74343f40ad05669bf7e381f166efb64c7ce238d681a4a60d907e4f3d16e5dafe7384

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-09-17
+
+- Replace `AngryIO.configure` / `AngryIO::Config` with a direct `AngryIO.enabled` accessor (still a callable, default `-> { true }`). This is a breaking change: replace `AngryIO.configure { |c| c.enabled = ... }` with `AngryIO.enabled = ...`.
+- Rename the core module from `AngryIo` to `AngryIO` (`AngryIO::Stream`, `AngryIO.enabled`, `AngryIO.with_real_streams`, etc.). This is a breaking change: no backwards-compatibility alias is provided, so any code referencing the old `AngryIo` constant must be updated. The lowercase gem name (`angry_io`) and require paths (`angry_io/rspec`, `angry_io/minitest`) are unchanged.
+
+## [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/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 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.
 
 ## Installation
 
@@ -29,21 +29,20 @@ 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 raises:
 
 ```
-IOError: AngryIo::Stream is not writable: "your output here"
+IOError: AngryIO::Stream is not writable: "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 +82,11 @@ 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`.
+`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
 
@@ -113,4 +108,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

@@ -3,14 +3,14 @@
 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
+# AngryIO::Stream instances 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
 
@@ -30,7 +30,7 @@ module AngryIo
     # real streams for the duration of the capture.
     module CaptureSubprocessIo
       def capture_subprocess_io(&block)
-        AngryIo.with_real_streams { super }
+        AngryIO.with_real_streams { super }
       end
     end
 
@@ -38,9 +38,10 @@ module AngryIo
       ::Minitest::Test.extend(ClassMethods)
       ::Minitest::Test.prepend(Adapter)
       ::Minitest::Assertions.prepend(CaptureSubprocessIo)
+      AngryIO.hook_active_support_stream!
     end
   end
 end
 
 require "minitest"
-AngryIo::Minitest.setup!
+AngryIO::Minitest.setup!

data/lib/angry_io/rspec.rb

@@ -2,11 +2,11 @@
 
 require "angry_io"
 
-# Registers an +around+ hook that swaps $stdout/$stderr to AngryIo::Stream
+# Registers an +around+ hook that swaps $stdout/$stderr to AngryIO::Stream
 # instances 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
@@ -15,11 +15,11 @@ module AngryIo
     # stream...
     module FromAnyProcess
       def to_stdout_from_any_process
-        AngryIo.with_real_streams { super }
+        AngryIO.with_real_streams { super }
       end
 
       def to_stderr_from_any_process
-        AngryIo.with_real_streams { super }
+        AngryIO.with_real_streams { super }
       end
     end
 
@@ -27,7 +27,7 @@ module AngryIo
     # are captured by the Tempfile instead of raising against the Angry stream.
     module CaptureStreamToTempfile
       def capture(block)
-        AngryIo.with_real_streams { super }
+        AngryIO.with_real_streams { super }
       end
     end
 
@@ -36,16 +36,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!
     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.3.0"
+module AngryIO
+  VERSION = "0.5.0"
 end

data/lib/angry_io.rb

@@ -3,7 +3,7 @@
 require "stringio"
 require_relative "angry_io/version"
 
-module AngryIo
+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.
@@ -18,7 +18,7 @@ module AngryIo
       strings.each do |string|
         next if string.to_s.empty?
 
-        raise IOError, "AngryIo::Stream is not writable: #{string.to_s.inspect}"
+        raise IOError, "AngryIO::Stream is not writable: \"#{string}\""
       end
       super
     end
@@ -26,32 +26,77 @@ module AngryIo
     # 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}"
+      raise IOError, "AngryIO::Stream is not writable: \"#{char}\""
+    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
 
-  Config = Struct.new(:enabled) do
-    def initialize
-      self.enabled = -> { true }
+  # 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 = 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
+    # 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
+    # +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
@@ -74,15 +119,20 @@ module AngryIo
     end
 
     # Run the block with the pre-swap $stdout/$stderr restored, re-swapping the
-    # AngryIo::Stream buffers afterwards. Helpers like Minitest's
+    # 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 +143,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.5.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -9,7 +9,7 @@ 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
+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.
@@ -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: []