angry_io 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8333b37ab325a405861724fec5d256e85255551879736909482389b3a203c14c
-  data.tar.gz: 2b3f00b29dc6573e4ddf3ef33b7c91856ee49d56d31d2a0b0b293a59ca02adec
+  metadata.gz: 597667423eb4ee7ad9daaf21e0ee59e86f361a07e37a5b6d7bdc03a89978ead6
+  data.tar.gz: df59a437ba441870cc0d6788748ea115d632b9c7770266a1ef901e4a966cb413
 SHA512:
-  metadata.gz: ef3525263035d341ada9c302472c468676a2196df6a1b57ed9b67d09e7c2d1bde7148dd18ca6fc6ed888e78bff6949ea97f4d645914d08e3a21094db77c306b4
-  data.tar.gz: 3ca41798772a5e17b5406b4d70446edb08eedffb21f5c62c1115c22e849e1b397cbe3ea5dec41bf44e3b84da4fcc0fcfc5e565396294226d8fe922ab9bc72e54
+  metadata.gz: 44154fa02cb72e8cbf89c5c24b3a4996a4600b0e3d17c484a50222875ea1b7fdc9c830150a7b618cee54eb05ce6cdab82fb1bc67dcebc4b42d7facd4578a5429
+  data.tar.gz: '083c923145f4247d847613ba082f1f9d509fd7dd7cdb9bce34b5db89f722051e5ca07ef4057af6c111a63656fa3fdf8be19957dce330a1cdf98babbb2c80e046'

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [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.
+- 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

data/README.md

@@ -1,18 +1,16 @@
 # 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.
 
-The name and the default opt-out metadata are a nod to [minitest](https://github.com/minitest/minitest)'s `i_suck_and_my_tests_are_order_dependent!`.
-
 ## Installation
 
 Add to your application's Gemfile:
 
 ```ruby
 group :test do
-  gem "angry_io", require: "angry_io/enable_for_ci_true"
+  gem "angry_io"
 end
 ```
 
@@ -24,17 +22,28 @@ gem install angry_io
 
 ## Usage
 
-The simplest setup is to point the Gemfile `require:` at `angry_io/enable_for_ci_true`. That file turns AngryIo on only when the `CI` environment variable is `"true"` — a convention set by GitHub Actions, GitLab CI, CircleCI, Travis, and others — and wires up whichever test framework is loaded (RSpec or Minitest); the other is a no-op.
+Depending on your test framework, you should require either `angry_io/rspec` or `angry_io/minitest`:
 
 ```ruby
-# Gemfile
-gem "angry_io", require: "angry_io/enable_for_ci_true"
+# spec_helper.rb (RSpec) or test_helper.rb (Minitest)
+require "angry_io/rspec"      # or "angry_io/minitest"
 ```
 
-That's it. Under `CI=true`, every test that writes to `$stdout` or `$stderr` raises:
+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"
+```
+
+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.
+AngryIo.configure do |config|
+  config.enabled = -> { ENV["CI"] == "true" }
+end
 ```
 
 ### Opting out
@@ -59,34 +68,30 @@ class PrintTest < Minitest::Test
 end
 ```
 
-### Manual setup
-
-If you'd rather control the gate yourself, require an adapter directly. `enabled` defaults to always-on, so it's most useful as a kill switch for environments where you need real output:
+The same call works in Minitest's spec format, inside the `describe` block:
 
 ```ruby
-# spec_helper.rb (RSpec) or test_helper.rb (Minitest)
-require "angry_io/rspec"      # or "angry_io/minitest"
+# Minitest spec format — opt out a whole describe block
+describe "printing" do
+  i_absolutely_need_to_write_to_stdout!
 
-# On by default; turn it off in environments where you need real output.
-AngryIo.configure do |config|
-  config.enabled = -> { ENV["ANGRY_IO"] != "off" }
+  it "prints" do
+    puts "ok"
+  end
 end
 ```
 
-Requiring `angry_io/rspec` or `angry_io/minitest` self-registers the hook if that framework is loaded; requiring plain `angry_io` gives you just the `AngryIo::Stream` class with no side effects.
-
 ## Configuration
 
-`AngryIo.configure` yields a config struct with two fields:
+`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. |
-| `opt_out_metadata` | `:i_absolutely_need_to_write_to_stdout` | The RSpec metadata symbol that opts an example out.                                                                   |
 
 ## 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

@@ -4,10 +4,8 @@ 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
-# +i_absolutely_need_to_write_to_stdout!+ in its body — a nod to minitest's own
-# +i_suck_and_my_tests_are_order_dependent!+. Force-loads Minitest so
-# registration works regardless of Bundler.require ordering; no-op if Minitest
-# isn't installed.
+# +i_absolutely_need_to_write_to_stdout!+ in its body. Force-loads Minitest so
+# registration works regardless of Bundler.require ordering.
 module AngryIo
   module Minitest
     module Adapter
@@ -26,17 +24,23 @@ 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
 
-begin
-  require "minitest"
-  AngryIo::Minitest.setup!
-rescue LoadError
-  # Minitest isn't installed; nothing to wire up.
-end
+require "minitest"
+AngryIo::Minitest.setup!

data/lib/angry_io/rspec.rb

@@ -3,27 +3,49 @@
 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 configured
-# metadata (default +:i_absolutely_need_to_write_to_stdout+). Force-loads
-# rspec-core so registration works regardless of Bundler.require ordering;
-# no-op if RSpec isn't installed.
+# 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 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|
-          opt_out = example.metadata.key?(AngryIo.config.opt_out_metadata) &&
-            example.metadata[AngryIo.config.opt_out_metadata]
+          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 }
         end
       end
+
+      ::RSpec::Matchers::BuiltIn::Output.prepend(FromAnyProcess)
+      ::RSpec::Matchers::BuiltIn::CaptureStreamToTempfile.prepend(CaptureStreamToTempfile)
     end
   end
 end
 
-begin
-  require "rspec/core"
-  AngryIo::RSpec.setup!
-rescue LoadError
-  # RSpec isn't installed; nothing to wire up.
-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.1.0"
+  VERSION = "0.3.0"
 end

data/lib/angry_io.rb

@@ -5,18 +5,34 @@ 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
 
-  Config = Struct.new(:enabled, :opt_out_metadata) do
+  Config = Struct.new(:enabled) do
     def initialize
       self.enabled = -> { true }
-      self.opt_out_metadata = :i_absolutely_need_to_write_to_stdout
     end
   end
 
@@ -43,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.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -23,7 +23,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/angry_io.rb
-- lib/angry_io/enable_for_ci_true.rb
 - lib/angry_io/minitest.rb
 - lib/angry_io/rspec.rb
 - lib/angry_io/version.rb

data/lib/angry_io/enable_for_ci_true.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Require this file from your Gemfile (+require: "angry_io/enable_for_ci_true"+)
-# to turn AngryIo on only when the +CI+ environment variable is +"true"+ — a
-# convention set by GitHub Actions, GitLab CI, CircleCI, Travis, and others.
-# Whichever test framework is loaded (RSpec or Minitest) wires itself up; the
-# other is a no-op.
-
-require "angry_io"
-
-AngryIo.configure do |config|
-  config.enabled = -> { ENV["CI"] == "true" }
-end
-
-require "angry_io/rspec"
-require "angry_io/minitest"