backspin 0.4.0 → 0.4.2

data/lib/backspin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 require "fileutils"
 require "open3"
@@ -21,7 +23,7 @@ module Backspin
   # Configuration for Backspin
   class Configuration
     attr_accessor :scrub_credentials
-    # The directory where backspin will store its files - defaults to spec/backspin_data
+    # The directory where backspin will store its files - defaults to fixtures/backspin
     attr_accessor :backspin_dir
     # Regex patterns to scrub from saved output
     attr_reader :credential_patterns
@@ -29,7 +31,7 @@ module Backspin
     def initialize
       @scrub_credentials = true
       @credential_patterns = default_credential_patterns
-      @backspin_dir = Pathname(Dir.pwd).join("spec", "backspin_data")
+      @backspin_dir = Pathname(Dir.pwd).join("fixtures", "backspin")
     end
 
     def add_credential_pattern(pattern)
@@ -50,22 +52,22 @@ module Backspin
     def default_credential_patterns
       [
         # AWS credentials
-        /AKIA[0-9A-Z]{16}/,                                    # AWS Access Key ID
-        /aws_secret_access_key\s*[:=]\s*["']?([A-Za-z0-9\/+=]{40})["']?/i,  # AWS Secret Key
-        /aws_session_token\s*[:=]\s*["']?([A-Za-z0-9\/+=]+)["']?/i,         # AWS Session Token
+        /AKIA[0-9A-Z]{16}/, # AWS Access Key ID
+        %r{aws_secret_access_key\s*[:=]\s*["']?([A-Za-z0-9/+=]{40})["']?}i,  # AWS Secret Key
+        %r{aws_session_token\s*[:=]\s*["']?([A-Za-z0-9/+=]+)["']?}i,         # AWS Session Token
 
         # Google Cloud credentials
-        /AIza[0-9A-Za-z\-_]{35}/,                              # Google API Key
+        /AIza[0-9A-Za-z\-_]{35}/, # Google API Key
         /[0-9]+-[0-9A-Za-z_]{32}\.apps\.googleusercontent\.com/, # Google OAuth2 client ID
-        /-----BEGIN (RSA )?PRIVATE KEY-----/,                  # Private keys
+        /-----BEGIN (RSA )?PRIVATE KEY-----/, # Private keys
 
         # Generic patterns
-        /api[_-]?key\s*[:=]\s*["']?([A-Za-z0-9\-_]{20,})["']?/i,  # Generic API keys
+        /api[_-]?key\s*[:=]\s*["']?([A-Za-z0-9\-_]{20,})["']?/i, # Generic API keys
         /auth[_-]?token\s*[:=]\s*["']?([A-Za-z0-9\-_]{20,})["']?/i, # Auth tokens
         /Bearer\s+([A-Za-z0-9\-_]+)/,                               # Bearer tokens
-        /password\s*[:=]\s*["']?([^"'\s]{8,})["']?/i,             # Passwords
-        /-p([^"'\s]{8,})/,                                          # MySQL-style password args
-        /secret\s*[:=]\s*["']?([A-Za-z0-9\-_]{20,})["']?/i       # Generic secrets
+        /password\s*[:=]\s*["']?([^"'\s]{8,})["']?/i, # Passwords
+        /-p([^"'\s]{8,})/, # MySQL-style password args
+        /secret\s*[:=]\s*["']?([A-Za-z0-9\-_]{20,})["']?/i # Generic secrets
       ]
     end
   end
@@ -91,7 +93,6 @@ module Backspin
       scrubbed = text.dup
       configuration.credential_patterns.each do |pattern|
         scrubbed.gsub!(pattern) do |match|
-          # Replace with asterisks of the same length
           "*" * match.length
         end
       end
@@ -104,22 +105,39 @@ module Backspin
     # @param options [Hash] Options for recording/verification
     # @option options [Symbol] :mode (:auto) Recording mode - :auto, :record, :verify, :playback
     # @option options [Proc] :filter Custom filter for recorded data
-    # @option options [Proc] :matcher Custom matcher for verification
+    # @option options [Proc, Hash] :matcher Custom matcher for verification
+    #   - Proc: ->(recorded, actual) { ... } for full command matching
+    #   - Hash: { stdout: ->(recorded, actual) { ... }, stderr: ->(recorded, actual) { ... } } for field-specific matching
+    #   - Hash with :all key: { all: ->(recorded, actual) { ... }, stdout: ->(recorded, actual) { ... } } for combined matching
+    #     When both :all and field matchers are present, both must pass for verification to succeed.
+    #     Fields without specific matchers always use exact equality, regardless of :all presence.
     # @return [RecordResult] Result object with output and status
     def run(record_name, options = {}, &block)
       raise ArgumentError, "record_name is required" if record_name.nil? || record_name.empty?
       raise ArgumentError, "block is required" unless block_given?
 
-      record_path = build_record_path(record_name)
+      record_path = Record.build_record_path(record_name)
       mode = determine_mode(options[:mode], record_path)
 
+      # Create or load the record based on mode
+      record = if mode == :record
+        Record.create(record_name)
+      else
+        Record.load_or_create(record_path)
+      end
+
+      # Create recorder with all needed context
+      recorder = Recorder.new(record: record, options: options, mode: mode)
+
+      # Execute the appropriate mode
       case mode
       when :record
-        perform_recording(record_name, record_path, options, &block)
+        recorder.setup_recording_stubs(:capture3, :system)
+        recorder.perform_recording(&block)
       when :verify
-        perform_verification(record_name, record_path, options, &block)
+        recorder.perform_verification(&block)
       when :playback
-        perform_playback(record_name, record_path, options, &block)
+        recorder.perform_playback(&block)
       else
         raise ArgumentError, "Unknown mode: #{mode}"
       end
@@ -136,7 +154,7 @@ module Backspin
 
       if result.verified? == false
         error_message = "Backspin verification failed!\n"
-        error_message += "Record: #{result.record_path}\n"
+        error_message += "Record: #{result.record.path}\n"
 
         # Use the error_message from the result which is now properly formatted
         error_message += "\n#{result.error_message}" if result.error_message
@@ -155,162 +173,5 @@ module Backspin
       # Auto mode: record if file doesn't exist, verify if it does
       File.exist?(record_path) ? :verify : :record
     end
-
-    def perform_recording(_record_name, record_path, options)
-      recorder = Recorder.new
-      recorder.record_calls(:capture3, :system)
-
-      output = yield
-
-      if output.is_a?(Array) && output.size == 3
-        stdout, stderr, status = output
-        status_int = status.respond_to?(:exitstatus) ? status.exitstatus : status
-        output = [stdout, stderr, status_int]
-      end
-
-      # Save the recording
-      FileUtils.mkdir_p(File.dirname(record_path))
-      record = Record.new(record_path)
-      record.clear
-      recorder.commands.each { |cmd| record.add_command(cmd) }
-      record.save(filter: options[:filter])
-
-      # Return result
-      RecordResult.new(
-        output: output,
-        mode: :record,
-        record_path: Pathname.new(record_path),
-        commands: recorder.commands
-      )
-    end
-
-    def perform_verification(_record_name, record_path, options)
-      record = Record.load_or_create(record_path)
-
-      raise RecordNotFoundError, "Record not found: #{record_path}" unless record.exists?
-      raise RecordNotFoundError, "No commands found in record" if record.empty?
-
-      # For verification, we need to track all commands executed
-      recorder = Recorder.new(mode: :verify, record: record)
-      recorder.setup_replay_stubs
-
-      # Track verification results for each command
-      command_diffs = []
-      command_index = 0
-
-      # Override stubs to verify each command as it's executed
-      allow(Open3).to receive(:capture3).and_wrap_original do |original_method, *args|
-        recorded_command = record.commands[command_index]
-
-        if recorded_command.nil?
-          raise RecordNotFoundError, "No more recorded commands, but tried to execute: #{args.inspect}"
-        end
-
-        if recorded_command.method_class != Open3::Capture3
-          raise RecordNotFoundError, "Expected #{recorded_command.method_class.name} but got Open3.capture3"
-        end
-
-        # Execute the actual command
-        stdout, stderr, status = original_method.call(*args)
-
-        # Create verification result
-        actual_result = CommandResult.new(
-          stdout: stdout,
-          stderr: stderr,
-          status: status.exitstatus
-        )
-
-        # Create CommandDiff to track the comparison
-        command_diffs << CommandDiff.new(
-          recorded_command: recorded_command,
-          actual_result: actual_result,
-          matcher: options[:matcher]
-        )
-
-        command_index += 1
-        [stdout, stderr, status]
-      end
-
-      allow_any_instance_of(Object).to receive(:system).and_wrap_original do |original_method, receiver, *args|
-        recorded_command = record.commands[command_index]
-
-        if recorded_command.nil?
-          raise RecordNotFoundError, "No more recorded commands, but tried to execute: system #{args.inspect}"
-        end
-
-        if recorded_command.method_class != ::Kernel::System
-          raise RecordNotFoundError, "Expected #{recorded_command.method_class.name} but got system"
-        end
-
-        # Execute the actual command
-        result = original_method.call(receiver, *args)
-
-        # Create verification result (system only gives us exit status)
-        actual_result = CommandResult.new(
-          stdout: "",
-          stderr: "",
-          status: result ? 0 : 1
-        )
-
-        # Create CommandDiff to track the comparison
-        command_diffs << CommandDiff.new(
-          recorded_command: recorded_command,
-          actual_result: actual_result,
-          matcher: options[:matcher]
-        )
-
-        command_index += 1
-        result
-      end
-
-      # Execute block
-      output = yield
-
-      # Check if all commands were executed
-      if command_index < record.commands.size
-        raise RecordNotFoundError, "Expected #{record.commands.size} commands but only #{command_index} were executed"
-      end
-
-      # Overall verification status
-      all_verified = command_diffs.all?(&:verified?)
-
-      RecordResult.new(
-        output: output,
-        mode: :verify,
-        verified: all_verified,
-        record_path: Pathname.new(record_path),
-        commands: record.commands,
-        command_diffs: command_diffs
-      )
-    end
-
-    def perform_playback(_record_name, record_path, _options)
-      record = Record.load_or_create(record_path)
-
-      raise RecordNotFoundError, "Record not found: #{record_path}" unless record.exists?
-      raise RecordNotFoundError, "No commands found in record" if record.empty?
-
-      # Setup replay mode - this will handle returning values for all commands
-      recorder = Recorder.new(mode: :replay, record: record)
-      recorder.setup_replay_stubs
-
-      # Execute block (all commands will be stubbed with recorded values)
-      output = yield
-
-      RecordResult.new(
-        output: output,
-        mode: :playback,
-        verified: true, # Always true for playback
-        record_path: Pathname.new(record_path),
-        commands: record.commands
-      )
-    end
-
-    def build_record_path(name)
-      backspin_dir = configuration.backspin_dir
-      backspin_dir.mkpath
-
-      File.join(backspin_dir, "#{name}.yml")
-    end
   end
 end

data/release.rake

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+# Simplified release tasks using gem-release
+# Install with: gem install 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} --github --tag --release"
+  end
+
+  desc "Create GitHub release for current version"
+  task :github do
+    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

data/script/lint

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Run Standard Ruby linter
+echo "Running Standard Ruby linter..."
+bundle exec standardrb "$@"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backspin
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Rob Sanheim
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rspec-mocks
   requirement: !ruby/object:Gem::Requirement
@@ -24,19 +38,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: ostruct
+  name: gem-release
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
-  type: :runtime
+        version: '2.2'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '2.2'
 description: Backspin is a Ruby library for characterization testing of command-line
   interfaces. Inspired by VCR's cassette-based approach, it records and replays CLI
   interactions to make testing faster and more deterministic.
@@ -47,6 +61,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
+- ".gem_release.yml"
 - ".gitignore"
 - ".rspec"
 - ".standard.yml"
@@ -56,12 +71,69 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
+- MATCH_ON_USAGE.md
 - README.md
 - Rakefile
 - backspin.gemspec
 - bin/rake
 - bin/rspec
 - bin/setup
+- examples/match_on_example.rb
+- fixtures/backspin/all_and_fields.yml
+- fixtures/backspin/all_bypass_equality.yml
+- fixtures/backspin/all_checks_equality.yml
+- fixtures/backspin/all_for_logging.yml
+- fixtures/backspin/all_matcher_basic.yml
+- fixtures/backspin/all_matcher_custom.yml
+- fixtures/backspin/all_matcher_demo.yml
+- fixtures/backspin/all_matcher_test.yml
+- fixtures/backspin/all_mode_filter.yml
+- fixtures/backspin/all_no_short_circuit.yml
+- fixtures/backspin/all_pass_field_fail.yml
+- fixtures/backspin/all_short_circuit.yml
+- fixtures/backspin/all_skips_equality.yml
+- fixtures/backspin/all_with_equality.yml
+- fixtures/backspin/all_with_fields.yml
+- fixtures/backspin/combined_fail_demo.yml
+- fixtures/backspin/combined_matcher_demo.yml
+- fixtures/backspin/credential_filter.yml
+- fixtures/backspin/echo_hello.yml
+- fixtures/backspin/echo_verify.yml
+- fixtures/backspin/episodes_filter.yml
+- fixtures/backspin/failure_test.yml
+- fixtures/backspin/field_matcher_demo.yml
+- fixtures/backspin/field_matcher_values.yml
+- fixtures/backspin/full_data_filter.yml
+- fixtures/backspin/key_confusion_test.yml
+- fixtures/backspin/match_on_any_fail.yml
+- fixtures/backspin/match_on_bad_format.yml
+- fixtures/backspin/match_on_fail.yml
+- fixtures/backspin/match_on_invalid.yml
+- fixtures/backspin/match_on_multiple.yml
+- fixtures/backspin/match_on_nil.yml
+- fixtures/backspin/match_on_other_fields.yml
+- fixtures/backspin/match_on_run_bang.yml
+- fixtures/backspin/match_on_run_bang_fail.yml
+- fixtures/backspin/match_on_single.yml
+- fixtures/backspin/mixed_calls.yml
+- fixtures/backspin/multi_command.yml
+- fixtures/backspin/multi_command_filter.yml
+- fixtures/backspin/multi_field_filter.yml
+- fixtures/backspin/multi_system.yml
+- fixtures/backspin/nil_filter.yml
+- fixtures/backspin/none_mode_test.yml
+- fixtures/backspin/path_test.yml
+- fixtures/backspin/playback_system.yml
+- fixtures/backspin/playback_test.yml
+- fixtures/backspin/stderr_test.yml
+- fixtures/backspin/string_symbol_test.yml
+- fixtures/backspin/system_echo.yml
+- fixtures/backspin/system_false.yml
+- fixtures/backspin/timestamp_test.yml
+- fixtures/backspin/use_record_filter.yml
+- fixtures/backspin/verify_system.yml
+- fixtures/backspin/verify_system_diff.yml
+- fixtures/backspin/version_test.yml
 - lib/backspin.rb
 - lib/backspin/command.rb
 - lib/backspin/command_diff.rb
@@ -70,6 +142,8 @@ files:
 - lib/backspin/record_result.rb
 - lib/backspin/recorder.rb
 - lib/backspin/version.rb
+- release.rake
+- script/lint
 homepage: https://github.com/rsanheim/backspin
 licenses:
 - MIT