angry_io 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e481e761566636d3cc9fcf965a2d5880a3b65e818cc1312c1c62897ccd6c16a1
-  data.tar.gz: 702fc8469bf85c8aec44fbfa861fcc86263b5bbb3bdb28b25338f26d3148caa7
+  metadata.gz: 597667423eb4ee7ad9daaf21e0ee59e86f361a07e37a5b6d7bdc03a89978ead6
+  data.tar.gz: df59a437ba441870cc0d6788748ea115d632b9c7770266a1ef901e4a966cb413
 SHA512:
-  metadata.gz: a862f0a1adf1077e3b7c6a43192692d22086e72f0761f7bd7629e13fc7b23908e798308ba969482b78d411686f34edee159544a2f93840d1391a18728f240c0a
-  data.tar.gz: 2ed4b06091d5afb5a9449e5fd3acd649995a09ee2e73ca8f4bf68b9f3cd27bef67d91959b4c2b9f503b1eec0847ff7b268d502e5c071fa11e866c11103a6ac18
+  metadata.gz: 44154fa02cb72e8cbf89c5c24b3a4996a4600b0e3d17c484a50222875ea1b7fdc9c830150a7b618cee54eb05ce6cdab82fb1bc67dcebc4b42d7facd4578a5429
+  data.tar.gz: '083c923145f4247d847613ba082f1f9d509fd7dd7cdb9bce34b5db89f722051e5ca07ef4057af6c111a63656fa3fdf8be19957dce330a1cdf98babbb2c80e046'

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [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,20 @@ 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)
     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,13 @@ 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)
     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.3.0"
 end

data/lib/angry_io.rb

@@ -5,11 +5,28 @@ 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
   end
 
@@ -42,15 +59,39 @@ 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.
+    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
+      $stdout = real_stdout
+      $stderr = real_stderr
+
+      begin
+        yield
+      ensure
+        $stdout = stdout_buffer
+        $stderr = stderr_buffer
+      end
+    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.3.0
 platform: ruby
 authors:
 - Benjamin Quorning