angry_io 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efd2cce37a69f805e637ea406088049b150bb0ff9192a7423100add8b7a29342
-  data.tar.gz: 4e25659b95836fc83544b295cf40b6428d094cf194356ff1e4e0c0b8e7c1ad42
+  metadata.gz: 89b93a80d709137ae29eb42cfda731bd4196ad40cfc4e56f2b3a12fc2961eee9
+  data.tar.gz: 49b1f5f622b6a1796013f0c370391a5e3941f6ffb67b8fb15b6b762470b8a093
 SHA512:
-  metadata.gz: 72682994c9e8647d1405a46aa15366c377325f31396767f6f6efe0ef6e6722f875bdce839a0094c04db309e39cb691a05d3daa43d5b4aeff2372430f1e69cee1
-  data.tar.gz: 51ee62f1212076d50984ed31c221760464fbd2f15990abd8f4c241fd4294bcc259bffa5b9c46ce54942ab6a5b178582272cd9c09de08dae7fa67baa874bf7e0b
+  metadata.gz: 80fbb90830d2836b63b73302b5a7f12dad52a8a05353290cc286b5493cd75446bd343f2c660f373716d0beb6e2b130014502751213fb22fb37e36c8d6d193650
+  data.tar.gz: 29f6e481c7e4dde2c6e45db4ae6c03d6621e496673565144b79149057e3d74343f40ad05669bf7e381f166efb64c7ce238d681a4a60d907e4f3d16e5dafe7384

data/CHANGELOG.md

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

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,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,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,17 +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!
+      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.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,7 +26,7 @@ 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
@@ -69,44 +69,34 @@ module AngryIo
   # capture/silence, the same way Minitest's capture_subprocess_io is handled.
   module ActiveSupportStreamCapture
     def capture(stream)
-      AngryIo.with_real_streams { super }
+      AngryIO.with_real_streams { super }
     end
 
     def silence_stream(stream)
-      # `stream` is bound at call time, so under AngryIo it's the StringIO
+      # `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) }
+      real = AngryIO.real_stream_for(stream)
+      AngryIO.with_real_streams { super(real || stream) }
     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
+    # 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
@@ -129,7 +119,7 @@ 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, or when the real streams are
@@ -154,7 +144,7 @@ module AngryIo
       end
     end
 
-    # If `stream` is one of the active swap's AngryIo::Stream buffers, return the
+    # 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.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: angry_io
 version: !ruby/object:Gem::Version
-  version: 0.4.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.