backspin 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3810a17b9b213b010cadd7419559fda50aed8dee3faad5865e824e765921339d
-  data.tar.gz: 400594d38ca7937da9095c78eb6578d5d384077a1cbbf78db97f06e133c6dcd0
+  metadata.gz: 34e60a632038ea59c7a0e95c64068032a5d3cf79584c99d622e36c6f5c610ec7
+  data.tar.gz: 49c6fc2e2902dc796072c6032c96862abf2111ad1220bd327ecc615ddb50f388
 SHA512:
-  metadata.gz: c2614110086b787c10b31504ae0eed80b32adc7a72d61709f6fba6245e093b35f92816227faebf781b3257e25b766c45676c47e74422176ae07fbc3eafaabce2
-  data.tar.gz: 6bb11f527a1aebc8ed495ccde7ca4deddf87b33f33f160cf76da13e02bc994e9b397cbaa59df2f30656cbd4a589ea70ebe24194743ac96a9b639fcda4cd9bf22
+  metadata.gz: de757488de5502e56a41e9910d7e118e93bcb1e77ef93c79014d048d59c5ac83b01644dd67c5a61a10996aa5d3ee3f372f957672cafecddcf7af9e6a4c329843
+  data.tar.gz: 805494ee3a1e0e40de7f3b1b05373d73d067798e0aed698989e5662d80ed6ef1d3b0af6a24bb6a3f1f3bc3a3affc609867c4b6daffe62c7291ee881b59499803

data/.circleci/config.yml

@@ -12,14 +12,22 @@ jobs:
       ruby-version:
         type: string
     docker:
-      - image: cimg/ruby:<< parameters.ruby-version >>
+      - image: ghcr.io/jdx/mise:2026.9.15-debian
+    environment:
+      MISE_RUBY_VERSION: << parameters.ruby-version >>
+      MISE_YES: "1"
     steps:
       - checkout
+      - run:
+          name: Install project tools
+          command: |
+            apt-get update && apt-get install -y --no-install-recommends build-essential libyaml-dev
+            mise install
       - ruby/install-deps:
-          key: gems-v1-ruby<< parameters.ruby-version >>
+          key: gems-v2-mise-ruby<< parameters.ruby-version >>
       - run:
-          name: Run specs
-          command: bundle exec rake spec
+          name: Run specs with Plur
+          command: plur spec
       - run:
           name: Run fake gem specs
           command: bundle exec rake spec:fake_gem

data/.github/workflows/release.yml

@@ -0,0 +1,24 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      previous-ref:
+        description: Tag or commit before the version increase (for retrying an unpublished release)
+        required: true
+        type: string
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  release:
+    uses: rsanheim/.github/.github/workflows/gem-release.yml@4ced52859dd60019b930a3f2023424e77b37ee2a
+    with:
+      gem: backspin
+      ruby-version: "4.0.0"

data/.gitignore

@@ -7,7 +7,6 @@
 /tmp/
 /.claude
 /.cursor
-/checksums/
 
 /backspin*.gem
 # rspec failure tracking

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.15.0
+* Added `stdin:` to `Backspin.run` and `Backspin.compare` to pipe a String into the command, replacing `sh -c` wrappers. For `compare`, give a side as `{command:, stdin:}`. Stdin is saved on every snapshot like stdout and stderr (empty when not given), so re-recorded files gain a `stdin` line, but it is not compared.
+* Changed `Backspin.compare` to skip credential scrubbing, so filters, matchers, and diffs see raw output and scrubbing can no longer hide mismatches (generic patterns could turn different paths into identical star runs). `run` and `capture` still scrub.
+* Added `env:` to `Backspin.compare` side Hashes (`{command:, env:, stdin:}`), so each command can get its own environment. A side's env replaces the top-level `env:` for that side, and each snapshot records the env it ran with.
+
+## 0.14.0
+* Improved verification errors with per-field summaries for stdout, stderr, and exit status, plus three lines of context around output changes. Long diffs are limited to 50 lines; set `BACKSPIN_FULL_DIFF=1` to show the full diff.
+* Preserved custom matcher failure reasons and made missing final newlines visible in output diffs.
+* Fixed `backspin_dir` configuration to accept String paths as well as Pathname objects.
+
 ## 0.13.0
 * Added `Backspin.compare(reference:, actual:)` for differential testing - runs both commands live and compares their filtered output, with no record file. Only stdout, stderr, and exit status are compared, so the two commands may differ in argv and env without normalization.
 * Added `Backspin::ReferenceCommandError`, raised when a compare's reference command produces no output at all (usually a sign it failed to start), rather than comparing empty to empty.

data/CLAUDE.md

@@ -24,9 +24,12 @@ bin/rspec spec/[file]:[line]    # Run specific test
 ### Building and Releasing
 ```bash
 bin/rake install     # Install gem locally for testing
-bin/rake release     # Release to RubyGems (updates version, tags, pushes)
+bin/rake build       # Build the gem locally
 ```
 
+Use the [shared release guide](https://github.com/rsanheim/.github#readme) and
+[Backspin quick reference](CONTRIBUTING.md#release-maintainer-setup) for releases.
+
 ### Code Quality
 ```bash
 script/lint                      # Run Standard Ruby linter

data/CONTRIBUTING.md

@@ -11,6 +11,7 @@ Note that Backspin is in early development and the API _will_ change before stab
 - [Making Changes](#making-changes)
 - [Testing](#testing)
 - [Submitting Changes](#submitting-changes)
+- [Release Maintainer Setup](#release-maintainer-setup)
 - [Code Style](#code-style)
 - [Reporting Issues](#reporting-issues)
 - [Feature Requests](#feature-requests)
@@ -161,6 +162,21 @@ end
 - Update examples in README.md if changing public APIs
 - Ensure CI passes (tests against Ruby 3.2, 3.3, 3.4, and 4.0)
 
+## Release Maintainer Setup
+
+Setup, trusted publishing, workflow updates, verification, and recovery live in
+[the shared release guide](https://github.com/rsanheim/.github#readme).
+
+Backspin quick reference:
+
+1. Update `lib/backspin/version.rb` and add matching notes to `CHANGELOG.md`.
+2. Synchronize Backspin's version in `Gemfile.lock` and
+   `fixtures/projects/dummy_cli_gem/Gemfile.lock` (including its checksum entry).
+3. Run the normal checks and `BUNDLE_FROZEN=true bundle exec rake build`.
+4. Merge the reviewed PR to `main` to publish.
+
+The caller is [`.github/workflows/release.yml`](.github/workflows/release.yml).
+
 ## Code Style
 
 Backspin uses [Standard Ruby](https://github.com/standardrb/standard) for code formatting. Run the linter before committing:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    backspin (0.13.0)
+    backspin (0.15.0)
       logger
 
 GEM

data/README.md

@@ -92,6 +92,26 @@ result.verified?        # true when they match
 
 Only stdout, stderr, and exit status are compared, so the two commands can differ in argv and environment without any normalization. `filter` and `matcher` work exactly as they do for `Backspin.run`, and a mismatch raises `Backspin::VerificationError` unless `raise_on_verification_failure` is disabled.
 
+To pipe data into a command's stdin, give that side as a Hash with `command:` and `stdin:`:
+
+```ruby
+Backspin.compare(
+  reference: {command: ["jq", "."], stdin: '{"a": 1}'},
+  actual: {command: ["my-jq", "."], stdin: '{"a": 1}'}
+)
+```
+
+A side Hash can also take `env:`, which replaces the top-level `env:` for that side:
+
+```ruby
+Backspin.compare(
+  reference: {command: ["jq", "."], env: {"HOME" => reference_home}},
+  actual: {command: ["my-jq", "."], env: {"HOME" => actual_home}}
+)
+```
+
+`compare` records nothing, so it does not scrub credentials. Filters, matchers, and failure diffs see raw output.
+
 If the reference command produces no output at all - usually a sign it failed to start rather than that its output is genuinely empty - `compare` raises `Backspin::ReferenceCommandError` instead of comparing empty to empty.
 
 ### Recording Modes
@@ -143,6 +163,7 @@ record_count: 3                            # increments on each write
 snapshot:
   command_type: "Open3::Capture3"
   args: ["echo", "hello"]
+  stdin: ""
   stdout: "hello\n"
   stderr: ""
   status: 0
@@ -164,6 +185,14 @@ Backspin.run(
 
 If `env:` is not provided, it is not passed to `Open3.capture3` and is not recorded.
 
+### Standard Input
+
+```ruby
+Backspin.run(["cat"], name: "with_stdin", stdin: "hello from stdin")
+```
+
+`stdin:` is passed to `Open3.capture3` as `stdin_data:` and saved in the record, but only stdout, stderr, and exit status are verified. `stdin:` is not supported with the block form.
+
 ### Custom Matchers
 
 For cases where full matching isn't suitable, you can override via `matcher:`. **NOTE**: If you provide
@@ -253,6 +282,23 @@ result.error_message  # Human-readable error if verification failed
 result.diff  # Diff between expected and actual output
 ```
 
+### Verification diffs
+
+Verification errors include the failure reason and a summary of changes to stdout, stderr,
+and exit status. Output diffs show three lines of context around each change, with `...`
+where unchanged lines are omitted. A `\ No newline at end of output` marker identifies
+output without a final newline.
+
+Diffs are limited to 50 lines by default. To see every diff line, run your tests with:
+
+```sh
+BACKSPIN_FULL_DIFF=1 bundle exec rake spec
+```
+
+The limit applies to `result.diff` and the diff portion of `result.error_message`. The
+environment variable removes the size limit; unchanged lines outside the context windows
+are still omitted.
+
 ### Configuration
 
 You can configure Backspin's behavior globally:
@@ -261,7 +307,7 @@ You can configure Backspin's behavior globally:
 Backspin.configure do |config|
   config.raise_on_verification_failure = false # default is true
   config.backspin_dir = "spec/fixtures/cli_records" # default is "fixtures/backspin"
-  config.scrub_credentials = false # default is true
+  config.scrub_credentials = false # default is true; scrubs run/capture records
 end
 ```
 
@@ -314,7 +360,7 @@ end
 
 If the CLI interaction you are recording contains sensitive data in stdout/stderr, you should be careful to make sure it is not recorded to YAML.
 
-By default, Backspin automatically tries to scrub common credential patterns from recorded stdout, stderr, args, and env values. Always review your record files before commiting them to source control.
+Backspin scrubs credentials from everything it records: by default it tries to scrub common credential patterns from stdout, stderr, args, env, and stdin before `run` and `capture` save them. `compare` records nothing, so it does not scrub. Always review your record files before commiting them to source control.
 
 ```ruby
 # This will automatically scrub AWS keys, API tokens, passwords, etc.
@@ -344,16 +390,22 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 This repo also includes a decoupled full-stack fixture gem at `fixtures/projects/dummy_cli_gem` that uses Backspin the way downstream projects do. Run it with:
 
 ```bash
-bundle exec rake full_stack:dummy_app
+bundle exec rake spec:fake_gem
 ```
 
 To re-record that fixture's committed YAML snapshots:
 
 ```bash
-bundle exec rake full_stack:record_dummy_app
+bundle exec rake spec:fake_gem_record
 ```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### Releasing
+
+See the [shared release guide](https://github.com/rsanheim/.github#readme) for
+setup and operation, and the [Backspin quick reference](CONTRIBUTING.md#release-maintainer-setup)
+for the files to update in a release PR.
 
 ## Contributing
 

data/Rakefile

@@ -34,5 +34,3 @@ namespace :spec do
 end
 
 task default: %i[spec standard]
-
-load "release.rake" if File.exist?("release.rake")

data/fixtures/projects/dummy_cli_gem/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../../..
   specs:
-    backspin (0.13.0)
+    backspin (0.15.0)
       logger
 
 PATH
@@ -40,7 +40,7 @@ DEPENDENCIES
   rspec (~> 3)
 
 CHECKSUMS
-  backspin (0.13.0)
+  backspin (0.15.0)
   diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
   dummy_cli_gem (0.1.0)
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203

data/lib/backspin/backspin_result.rb

@@ -36,10 +36,18 @@ module Backspin
       return nil unless verified? == false
       return "Output verification failed" unless @command_diff
 
-      msg = "Output verification failed:\n\n"
-      msg += @command_diff.summary
-      msg += "\n#{@command_diff.diff}" if @command_diff.diff
-      msg
+      parts = ["Output verification failed:", @command_diff.summary, "", "Summary:"]
+      @command_diff.field_summary.each do |line|
+        parts << "  #{line}"
+      end
+
+      diff = @command_diff.diff
+      if diff && !diff.empty?
+        parts << ""
+        parts << diff
+      end
+
+      parts.join("\n")
     end
 
     def success?

data/lib/backspin/command_diff.rb

@@ -3,6 +3,9 @@
 module Backspin
   # Represents the difference between expected and actual snapshots.
   class CommandDiff
+    CONTEXT_LINES = 3
+    MAX_DIFF_LINES = 50
+
     attr_reader :expected, :actual, :matcher
 
     def initialize(expected:, actual:, matcher: nil, filter: nil, filter_on: :both)
@@ -26,6 +29,15 @@ module Backspin
       @verified = @matcher.match?
     end
 
+    # @return [Array<String>] Per-field change status lines
+    def field_summary
+      lines = []
+      lines << stdout_field_summary
+      lines << stderr_field_summary
+      lines << status_field_summary
+      lines
+    end
+
     # @return [String, nil] Human-readable diff if not verified
     def diff
       return nil if verified?
@@ -48,7 +60,8 @@ module Backspin
         parts << "Exit status: expected #{expected_compare.status}, got #{actual_compare.status}"
       end
 
-      parts.join("\n\n")
+      result = parts.join("\n\n")
+      maybe_truncate(result)
     end
 
     # @return [String] Single line summary for error messages
@@ -62,6 +75,30 @@ module Backspin
 
     private
 
+    def stdout_field_summary
+      if expected_compare.stdout == actual_compare.stdout
+        "stdout: unchanged"
+      else
+        "stdout: changed"
+      end
+    end
+
+    def stderr_field_summary
+      if expected_compare.stderr == actual_compare.stderr
+        "stderr: unchanged"
+      else
+        "stderr: changed"
+      end
+    end
+
+    def status_field_summary
+      if expected_compare.status == actual_compare.status
+        "status: unchanged"
+      else
+        "status: changed (expected #{expected_compare.status}, actual #{actual_compare.status})"
+      end
+    end
+
     def command_types_match?
       expected.command_type == actual.command_type
     end
@@ -83,25 +120,77 @@ module Backspin
     end
 
     def generate_line_diff(expected, actual)
-      expected_lines = (expected || "").lines
-      actual_lines = (actual || "").lines
+      expected_lines = split_lines(expected)
+      actual_lines = split_lines(actual)
+      max_lines = [expected_lines.length, actual_lines.length].max
+
+      changed = Array.new(max_lines, false)
+      max_lines.times do |i|
+        changed[i] = (expected_lines[i] != actual_lines[i])
+      end
+
+      visible = Array.new(max_lines, false)
+      max_lines.times do |i|
+        next unless changed[i]
+        range_start = [i - CONTEXT_LINES, 0].max
+        range_end = [i + CONTEXT_LINES, max_lines - 1].min
+        (range_start..range_end).each { |j| visible[j] = true }
+      end
 
       diff_lines = []
-      max_lines = [expected_lines.length, actual_lines.length].max
+      first_visible = visible.index(true)
+      diff_lines << "..." if first_visible&.positive?
+      in_hunk = false
 
       max_lines.times do |i|
-        expected_line = expected_lines[i]
-        actual_line = actual_lines[i]
+        unless visible[i]
+          if in_hunk
+            diff_lines << "..."
+            in_hunk = false
+          end
+          next
+        end
+
+        in_hunk = true
 
-        if expected_line != actual_line
-          diff_lines << "-#{expected_line.chomp}" if expected_line
-          diff_lines << "+#{actual_line.chomp}" if actual_line
+        if changed[i]
+          diff_lines << "-#{render_line(expected_lines[i])}" if i < expected_lines.length
+          diff_lines << "+#{render_line(actual_lines[i])}" if i < actual_lines.length
+        else
+          line = expected_lines[i] || actual_lines[i]
+          diff_lines << " #{render_line(line)}"
         end
       end
 
       diff_lines.join("\n")
     end
 
+    def split_lines(value)
+      (value || "").lines
+    end
+
+    def render_line(line)
+      rendered = line.to_s.chomp
+      return rendered if line.to_s.end_with?("\n")
+
+      "#{rendered}\n\\ No newline at end of output"
+    end
+
+    def maybe_truncate(diff_text)
+      return diff_text if full_diff?
+
+      lines = diff_text.lines
+      return diff_text if lines.length <= MAX_DIFF_LINES
+
+      truncated = lines.first(MAX_DIFF_LINES).join
+      truncated.chomp!
+      truncated + "\n(diff truncated, set BACKSPIN_FULL_DIFF=1 for full output)"
+    end
+
+    def full_diff?
+      ENV["BACKSPIN_FULL_DIFF"] == "1"
+    end
+
     attr_reader :expected_compare
 
     attr_reader :actual_compare

data/lib/backspin/configuration.rb

@@ -8,7 +8,7 @@ module Backspin
   class Configuration
     attr_accessor :scrub_credentials
     # The directory where backspin will store its files - defaults to fixtures/backspin
-    attr_accessor :backspin_dir
+    attr_reader :backspin_dir
     # Whether to raise an exception when verification fails in `run`/`capture` - defaults to true
     attr_accessor :raise_on_verification_failure
     # Logger for Backspin diagnostics - defaults to WARN level, logfmt-lite format
@@ -24,6 +24,10 @@ module Backspin
       @logger = default_logger
     end
 
+    def backspin_dir=(path)
+      @backspin_dir = Pathname.new(path)
+    end
+
     def add_credential_pattern(pattern)
       @credential_patterns << pattern
     end

data/lib/backspin/snapshot.rb

@@ -3,14 +3,16 @@
 module Backspin
   # Represents a single captured execution snapshot.
   class Snapshot
-    attr_reader :command_type, :args, :env, :stdout, :stderr, :status, :recorded_at
+    attr_reader :command_type, :args, :env, :stdin, :stdout, :stderr, :status, :recorded_at
 
-    def initialize(command_type:, args:, env: nil, stdout: "", stderr: "", status: 0, recorded_at: nil)
+    def initialize(command_type:, args:, env: nil, stdin: "", stdout: "", stderr: "", status: 0, recorded_at: nil, scrub: Backspin.configuration.scrub_credentials)
+      @scrub = scrub
       @command_type = command_type
       @args = sanitize_args(args)
       @env = env.nil? ? nil : sanitize_env(env)
-      @stdout = Backspin.scrub_text((stdout || "").dup).freeze
-      @stderr = Backspin.scrub_text((stderr || "").dup).freeze
+      @stdin = scrub_string((stdin || "").dup).freeze
+      @stdout = scrub_string((stdout || "").dup).freeze
+      @stderr = scrub_string((stderr || "").dup).freeze
       @status = status || 0
       @recorded_at = recorded_at.nil? ? nil : recorded_at.dup.freeze
       @serialized_hash = build_serialized_hash
@@ -42,6 +44,7 @@ module Backspin
         command_type: command_type,
         args: data["args"],
         env: data["env"],
+        stdin: data["stdin"],
         stdout: data["stdout"],
         stderr: data["stderr"],
         status: data["status"],
@@ -55,6 +58,7 @@ module Backspin
       data = {
         "command_type" => command_type.name,
         "args" => args,
+        "stdin" => stdin,
         "stdout" => stdout,
         "stderr" => stderr,
         "status" => status,
@@ -64,25 +68,25 @@ module Backspin
       deep_freeze(data)
     end
 
-    def scrub_args(value)
-      return value unless Backspin.configuration.scrub_credentials && value
+    def scrub_string(text)
+      @scrub ? Backspin.scrub_text(text) : text
+    end
 
+    def scrub_args(value)
       case value
       when String
-        Backspin.scrub_text(value)
+        scrub_string(value)
       when Array
         value.map { |entry| scrub_args(entry) }
       when Hash
-        value.transform_values { |entry| entry.is_a?(String) ? Backspin.scrub_text(entry) : entry }
+        value.transform_values { |entry| entry.is_a?(String) ? scrub_string(entry) : entry }
       else
         value
       end
     end
 
     def scrub_env(value)
-      return value unless Backspin.configuration.scrub_credentials && value
-
-      value.transform_values { |entry| entry.is_a?(String) ? Backspin.scrub_text(entry) : entry }
+      value.transform_values { |entry| entry.is_a?(String) ? scrub_string(entry) : entry }
     end
 
     def sanitize_args(value)

data/lib/backspin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Backspin
-  VERSION = "0.13.0"
+  VERSION = "0.15.0"
 end

data/lib/backspin.rb

@@ -76,17 +76,19 @@ module Backspin
     # @param command [String, Array] Command to execute via Open3.capture3
     # @param name [String] Name for the record file
     # @param env [Hash] Environment variables to pass to Open3.capture3
+    # @param stdin [String] Data written to the command's stdin (recorded, not compared)
     # @param mode [Symbol] Recording mode - :auto, :record, :verify
     # @param matcher [Proc, Hash] Custom matcher for verification
     # @param filter [Proc] Custom filter for recorded data/canonicalization
     # @param filter_on [Symbol] Filter application mode - :both (default), :record
     # @return [BackspinResult] Aggregate result for this run
-    def run(command = nil, name:, env: nil, mode: :auto, matcher: nil, filter: nil, filter_on: :both, &block)
+    def run(command = nil, name:, env: nil, stdin: nil, mode: :auto, matcher: nil, filter: nil, filter_on: :both, &block)
       validate_filter_on!(filter_on)
 
       if block_given?
         raise ArgumentError, "command must be omitted when using a block" unless command.nil?
         raise ArgumentError, "env is not supported when using a block" unless env.nil?
+        raise ArgumentError, "stdin is not supported when using a block" unless stdin.nil?
 
         return perform_capture(name, mode: mode, matcher: matcher, filter: filter, filter_on: filter_on, &block)
       end
@@ -97,6 +99,7 @@ module Backspin
         command,
         name: name,
         env: env,
+        stdin: stdin,
         mode: mode,
         matcher: matcher,
         filter: filter,
@@ -126,22 +129,31 @@ module Backspin
     # Only stdout, stderr, and status are compared, so the two commands may
     # differ in argv and env without any normalization.
     #
-    # @param reference [String, Array] Command that defines the correct output
-    # @param actual [String, Array] Command under test
+    # Either side may be a Hash of {command:, env:, stdin:} to give that command
+    # its own env or stdin. A side's env replaces the top-level env for that
+    # side. Stdin is recorded on each snapshot, not compared.
+    #
+    # Credentials are not scrubbed, so the filter, matcher, and diff see raw output.
+    #
+    # @param reference [String, Array, Hash] Command that defines the correct output
+    # @param actual [String, Array, Hash] Command under test
     # @param env [Hash] Environment variables passed to both commands
     # @param matcher [Proc, Hash] Custom matcher for verification
     # @param filter [Proc] Custom filter applied to both sides before comparing
     # @return [BackspinResult] expected = reference, actual = command under test
     def compare(reference:, actual:, env: nil, matcher: nil, filter: nil)
-      normalized_env = normalize_env(env)
+      reference_command, reference_env, reference_stdin = reference.is_a?(Hash) ? reference.values_at(:command, :env, :stdin) : [reference, nil, nil]
+      actual_command, actual_env, actual_stdin = actual.is_a?(Hash) ? actual.values_at(:command, :env, :stdin) : [actual, nil, nil]
+      reference_env = normalize_env(reference_env || env)
+      actual_env = normalize_env(actual_env || env)
 
-      expected_snapshot, = capture_command_snapshot(reference, normalized_env)
+      expected_snapshot, = capture_command_snapshot(reference_command, reference_env, reference_stdin, scrub: false)
       if expected_snapshot.stdout.empty? && expected_snapshot.stderr.empty?
         raise ReferenceCommandError,
           "Reference command produced no output (exit status #{expected_snapshot.status}): #{reference.inspect}"
       end
 
-      actual_snapshot, = capture_command_snapshot(actual, normalized_env)
+      actual_snapshot, = capture_command_snapshot(actual_command, actual_env, actual_stdin, scrub: false)
 
       command_diff = CommandDiff.new(
         expected: expected_snapshot,
@@ -188,7 +200,7 @@ module Backspin
       result
     end
 
-    def perform_command_run(command, name:, env:, mode:, matcher:, filter:, filter_on:)
+    def perform_command_run(command, name:, env:, stdin:, mode:, matcher:, filter:, filter_on:)
       record_path = Record.build_record_path(name)
       mode = determine_mode(mode, record_path)
       validate_mode!(mode)
@@ -199,7 +211,7 @@ module Backspin
 
       result = case mode
       when :record
-        actual_snapshot, output = capture_command_snapshot(command, normalized_env)
+        actual_snapshot, output = capture_command_snapshot(command, normalized_env, stdin)
         record.set_snapshot(actual_snapshot)
         record.save(filter: filter)
         BackspinResult.new(
@@ -217,7 +229,7 @@ module Backspin
           raise RecordFormatError, "Invalid record format: expected Open3::Capture3 for run"
         end
 
-        actual_snapshot, output = capture_command_snapshot(command, normalized_env)
+        actual_snapshot, output = capture_command_snapshot(command, normalized_env, stdin)
         command_diff = CommandDiff.new(
           expected: expected_snapshot,
           actual: actual_snapshot,
@@ -243,16 +255,18 @@ module Backspin
       result
     end
 
-    def capture_command_snapshot(command, env)
-      stdout, stderr, status = execute_command(command, env)
+    def capture_command_snapshot(command, env, stdin, scrub: configuration.scrub_credentials)
+      stdout, stderr, status = execute_command(command, env, stdin)
       snapshot = Snapshot.new(
         command_type: Open3::Capture3,
         args: command,
         env: env,
+        stdin: stdin,
         stdout: stdout,
         stderr: stderr,
         status: status.exitstatus,
-        recorded_at: Time.now.utc.iso8601
+        recorded_at: Time.now.utc.iso8601,
+        scrub: scrub
       )
       [snapshot, [stdout, stderr, status]]
     end
@@ -264,13 +278,13 @@ module Backspin
       env.empty? ? nil : env
     end
 
-    def execute_command(command, env)
+    def execute_command(command, env, stdin)
       case command
       when String
-        env ? Open3.capture3(env, command) : Open3.capture3(command)
+        env ? Open3.capture3(env, command, stdin_data: stdin) : Open3.capture3(command, stdin_data: stdin)
       when Array
         raise ArgumentError, "command array cannot be empty" if command.empty?
-        env ? Open3.capture3(env, *command) : Open3.capture3(*command)
+        env ? Open3.capture3(env, *command, stdin_data: stdin) : Open3.capture3(*command, stdin_data: stdin)
       else
         raise ArgumentError, "command must be a String or Array"
       end

data/mise.toml

@@ -1,2 +1,3 @@
 [tools]
 ruby = "4.0.0"
+"github:rsanheim/plur" = { version = "latest", minimum_release_age = "0s" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backspin
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Rob Sanheim
@@ -33,7 +33,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
-- ".gem_release.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
@@ -84,7 +84,6 @@ files:
 - lib/backspin/snapshot.rb
 - lib/backspin/version.rb
 - mise.toml
-- release.rake
 - script/lint
 homepage: https://github.com/rsanheim/backspin
 licenses:
@@ -107,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Record and replay CLI interactions for testing
 test_files: []

data/.gem_release.yml

@@ -1,13 +0,0 @@
-# Configuration for gem-release
-bump:
-  commit: true
-  message: "Bump version to %{version}"
-  skip_ci: false
-  push: true
-
-tag:
-  tag: v%{version}
-  sign: true
-
-release:
-  host: https://rubygems.org

data/release.rake

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-
-# Simplified release tasks using gem-release
-# Install with: gem install gem-release
-# https://github.com/svenfuchs/gem-release
-namespace :release do
-  desc "Release a new version (bump, tag, release)"
-  task :version, [:level] do |t, args|
-    level = args[:level] || "patch"
-
-    # Pre-release checks
-    # Rake::Task["release:check"].invoke
-
-    puts "\nReleasing #{level} version..."
-
-    # Use gem-release to bump, tag, and release to rubygems and github
-    sh "gem bump --version #{level}"
-    new_version = File.read("lib/backspin/version.rb").match(/VERSION = "(\d+\.\d+\.\d+)"/)[1]
-
-    sh "bundle install"
-    sh "git commit -am 'Bump version to #{new_version}'"
-    sh "git push"
-
-    sh "gem release --tag --push"
-    Rake::Task["release:github"].invoke(new_version)
-  end
-
-  desc "Create GitHub release for specified version or current version"
-  task :github, [:version] do |t, args|
-    version = args[:version] || Backspin::VERSION
-
-    if system("which gh > /dev/null 2>&1")
-      puts "\nCreating GitHub release for v#{version}..."
-      sh "gh release create v#{version} --title 'Release v#{version}' --generate-notes"
-    else
-      puts "\nGitHub CLI not found. Create release manually at:"
-      puts "https://github.com/rsanheim/backspin/releases/new?tag=v#{version}"
-    end
-  end
-
-  desc "Check if ready for release"
-  task :check do
-    require "open-uri"
-    require "json"
-
-    current_version = Backspin::VERSION
-    errors = []
-
-    # Check RubyGems for latest version
-    begin
-      gem_data = JSON.parse(URI.open("https://rubygems.org/api/v1/gems/backspin.json").read)
-      latest_version = gem_data["version"]
-
-      if Gem::Version.new(current_version) <= Gem::Version.new(latest_version)
-        errors << "Current version (#{current_version}) is not greater than latest released version (#{latest_version})"
-      else
-        puts "✓ Version #{current_version} is ready for release (latest: #{latest_version})"
-      end
-    rescue => e
-      puts "⚠ Could not check RubyGems version: #{e.message}"
-    end
-
-    # Check git status
-    if system("git diff --quiet && git diff --cached --quiet")
-      puts "✓ No uncommitted changes"
-    else
-      errors << "You have uncommitted changes"
-    end
-
-    # Check branch
-    current_branch = `git rev-parse --abbrev-ref HEAD`.strip
-    if current_branch != "main"
-      puts "⚠ Not on main branch (currently on #{current_branch})"
-      print "Continue anyway? (y/N): "
-      response = $stdin.gets.chomp
-      errors << "Not on main branch" unless response.downcase == "y"
-    else
-      puts "✓ On main branch"
-    end
-
-    unless errors.empty?
-      puts "\n❌ Cannot release:"
-      errors.each { |e| puts "  - #{e}" }
-      abort
-    end
-
-    puts "\n✅ All checks passed!"
-  end
-end
-
-# Convenience tasks
-desc "Release patch version"
-task "release:patch" => ["release:version"]
-
-desc "Release minor version"
-task "release:minor" do
-  Rake::Task["release:version"].invoke("minor")
-end
-
-desc "Release major version"
-task "release:major" do
-  Rake::Task["release:version"].invoke("major")
-end