backspin 0.4.1 → 0.4.2

data/lib/backspin/recorder.rb

@@ -1,25 +1,30 @@
+# frozen_string_literal: true
+
 require "open3"
 require "ostruct"
 require "rspec/mocks"
+require "backspin/command_result"
+require "backspin/command_diff"
 
 module Backspin
   # Handles stubbing and recording of command executions
   class Recorder
     include RSpec::Mocks::ExampleMethods
-    SUPPORTED_COMMAND_TYPES = [:capture3, :system]
+    SUPPORTED_COMMAND_TYPES = %i[capture3 system].freeze
 
-    attr_reader :commands, :verification_data, :mode, :record
+    attr_reader :commands, :mode, :record, :options
 
-    def initialize(mode: :record, record: nil)
+    def initialize(mode: :record, record: nil, options: {})
       @mode = mode
       @record = record
+      @options = options
       @commands = []
-      @verification_data = {}
+      @playback_index = 0
+      @command_diffs = []
     end
 
-    def record_calls(*command_types)
+    def setup_recording_stubs(*command_types)
       command_types = SUPPORTED_COMMAND_TYPES if command_types.empty?
-
       command_types.each do |command_type|
         record_call(command_type)
       end
@@ -32,67 +37,110 @@ module Backspin
       when :capture3
         setup_capture3_call_stub
       else
-        raise ArgumentError, "Unsupported command type: #{command_type} - currently supported types: #{SUPPORTED_COMMAND_TYPES.join(", ")}"
+        raise ArgumentError,
+          "Unsupported command type: #{command_type} - currently supported types: #{SUPPORTED_COMMAND_TYPES.join(", ")}"
       end
     end
 
-    # Setup stubs for playback mode - just return recorded values
-    def setup_playback_stub(command)
-      if command.method_class == Open3::Capture3
-        actual_status = OpenStruct.new(exitstatus: command.status)
-        allow(Open3).to receive(:capture3).and_return([command.stdout, command.stderr, actual_status])
-      elsif command.method_class == ::Kernel::System
-        # For system, return true if exit status was 0
-        allow_any_instance_of(Object).to receive(:system).and_return(command.status == 0)
-      end
+    # Records registered commands, adds them to the record, saves the record, and returns the overall RecordResult
+    def perform_recording
+      result = yield
+      record.save(filter: options[:filter])
+      RecordResult.new(output: result, mode: :record, record: record)
     end
 
-    # Setup stubs for verification - capture actual output
-    def setup_verification_stub(command)
-      @verification_data = {}
-
-      if command.method_class == Open3::Capture3
-        allow(Open3).to receive(:capture3).and_wrap_original do |original_method, *args|
-          stdout, stderr, status = original_method.call(*args)
-          @verification_data["stdout"] = stdout
-          @verification_data["stderr"] = stderr
-          @verification_data["status"] = status.exitstatus
-          [stdout, stderr, status]
-        end
-      elsif command.method_class == ::Kernel::System
-        allow_any_instance_of(Object).to receive(:system).and_wrap_original do |original_method, receiver, *args|
-          # Execute the real system call
-          result = original_method.call(receiver, *args)
+    # Performs verification by executing commands and comparing with recorded values
+    def perform_verification
+      raise RecordNotFoundError, "Record not found: #{record.path}" unless record.exists?
+      raise RecordNotFoundError, "No commands found in record" if record.empty?
 
-          # For system calls, we only track the exit status
-          @verification_data["stdout"] = ""
-          @verification_data["stderr"] = ""
-          @verification_data["status"] = result ? 0 : 1
+      # Initialize tracking variables
+      @command_diffs = []
+      @command_index = 0
 
-          result
+      # Setup verification stubs for capture3
+      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
+
+        stdout, stderr, status = original_method.call(*args)
+
+        actual_command = Command.new(
+          method_class: Open3::Capture3,
+          args: args,
+          stdout: stdout,
+          stderr: stderr,
+          status: status.exitstatus
+        )
+
+        @command_diffs << CommandDiff.new(recorded_command: recorded_command, actual_command: actual_command, matcher: options[:matcher])
+        @command_index += 1
+        [stdout, stderr, status]
       end
+
+      # Setup verification stubs for system
+      allow_any_instance_of(Object).to receive(:system).and_wrap_original do |original_method, receiver, *args|
+        recorded_command = record.commands[@command_index]
+
+        result = original_method.call(receiver, *args)
+
+        actual_command = Command.new(
+          method_class: ::Kernel::System,
+          args: args,
+          stdout: "",
+          stderr: "",
+          status: result ? 0 : 1
+        )
+
+        # Create CommandDiff to track the comparison
+        @command_diffs << CommandDiff.new(recorded_command: recorded_command, actual_command: actual_command, matcher: options[:matcher])
+
+        @command_index += 1
+        result
+      end
+
+      output = yield
+
+      all_verified = @command_diffs.all?(&:verified?)
+
+      RecordResult.new(
+        output: output,
+        mode: :verify,
+        verified: all_verified,
+        record: record,
+        command_diffs: @command_diffs
+      )
     end
 
-    # Setup stubs for replay mode - returns recorded values for multiple commands
-    def setup_replay_stubs
-      raise ArgumentError, "Record required for replay mode" unless @record
+    # Performs playback by returning recorded values without executing actual commands
+    def perform_playback
+      raise RecordNotFoundError, "Record not found: #{record.path}" unless record.exists?
+      raise RecordNotFoundError, "No commands found in record" if record.empty?
 
+      # Setup replay stubs
       setup_capture3_replay_stub
       setup_system_replay_stub
+
+      # 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: record
+      )
     end
 
     private
 
     def setup_capture3_replay_stub
-      allow(Open3).to receive(:capture3) do |*args|
+      allow(Open3).to receive(:capture3) do |*_args|
         command = @record.next_command
 
-        # Make sure this is a capture3 command
-        unless command.method_class == Open3::Capture3
-          raise RecordNotFoundError, "Expected Open3::Capture3 command but got #{command.method_class.name}"
-        end
-
         recorded_stdout = command.stdout
         recorded_stderr = command.stderr
         recorded_status = OpenStruct.new(exitstatus: command.status)
@@ -104,14 +152,10 @@ module Backspin
     end
 
     def setup_system_replay_stub
-      allow_any_instance_of(Object).to receive(:system) do |receiver, *args|
+      allow_any_instance_of(Object).to receive(:system) do |_receiver, *_args|
         command = @record.next_command
 
-        unless command.method_class == ::Kernel::System
-          raise RecordNotFoundError, "Expected Kernel::System command but got #{command.method_class.name}"
-        end
-
-        command.status == 0
+        command.status.zero?
       rescue NoMoreRecordingsError => e
         raise RecordNotFoundError, e.message
       end
@@ -135,7 +179,7 @@ module Backspin
           status: status.exitstatus,
           recorded_at: Time.now.iso8601
         )
-        @commands << command
+        record.add_command(command)
 
         [stdout, stderr, status]
       end
@@ -154,7 +198,8 @@ module Backspin
           args
         end
 
-        stdout, stderr = "", ""
+        stdout = ""
+        stderr = ""
         status = result ? 0 : 1
 
         command = Command.new(
@@ -165,7 +210,7 @@ module Backspin
           status: status,
           recorded_at: Time.now.iso8601
         )
-        @commands << command
+        record.add_command(command)
 
         result
       end

data/lib/backspin/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Backspin
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/lib/backspin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "yaml"
 require "fileutils"
 require "open3"
@@ -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 "$@"