backspin 0.7.0 → 0.8.0

data/lib/backspin/record.rb

@@ -3,10 +3,8 @@
 module Backspin
   class RecordFormatError < StandardError; end
 
-  class NoMoreRecordingsError < StandardError; end
-
   class Record
-    FORMAT_VERSION = "2.0"
+    FORMAT_VERSION = "3.0"
     attr_reader :path, :commands, :first_recorded_at
 
     def self.load_or_create(path)
@@ -39,7 +37,6 @@ module Backspin
       @path = path
       @commands = []
       @first_recorded_at = nil
-      @playback_index = 0
     end
 
     def add_command(command)
@@ -60,9 +57,7 @@ module Backspin
 
     def reload
       @commands = []
-      @playback_index = 0
       load_from_file if File.exist?(@path)
-      @playback_index = 0 # Reset again after loading to ensure it's at 0
     end
 
     def exists?
@@ -77,17 +72,8 @@ module Backspin
       @commands.size
     end
 
-    def next_command
-      raise NoMoreRecordingsError, "No more recordings available for replay" if @playback_index >= @commands.size
-
-      command = @commands[@playback_index]
-      @playback_index += 1
-      command
-    end
-
     def clear
       @commands = []
-      @playback_index = 0
     end
 
     # private
@@ -95,12 +81,17 @@ module Backspin
     def load_from_file
       data = YAML.load_file(@path.to_s)
 
-      unless data.is_a?(Hash) && data["format_version"] == "2.0"
-        raise RecordFormatError, "Invalid record format: expected format version 2.0"
+      unless data.is_a?(Hash) && data["format_version"] == FORMAT_VERSION
+        raise RecordFormatError, "Invalid record format: expected format version #{FORMAT_VERSION}"
+      end
+
+      commands = data["commands"]
+      unless commands.is_a?(Array)
+        raise RecordFormatError, "Invalid record format: missing commands"
       end
 
       @first_recorded_at = data["first_recorded_at"]
-      @commands = data["commands"].map { |command_data| Command.from_h(command_data) }
+      @commands = commands.map { |command_data| Command.from_h(command_data) }
     rescue Psych::SyntaxError => e
       raise RecordFormatError, "Invalid record format: #{e.message}"
     end

data/lib/backspin/record_result.rb

@@ -34,11 +34,6 @@ module Backspin
       @verified
     end
 
-    # @return [Boolean] true if this result is from playback mode
-    def playback?
-      mode == :playback
-    end
-
     # @return [String, nil] Human-readable error message if verification failed
     def error_message
       return nil unless verified? == false
@@ -142,7 +137,6 @@ module Backspin
       hash = {
         mode: mode,
         recorded: recorded?,
-        playback: playback?,
         stdout: stdout,
         stderr: stderr,
         status: status

data/lib/backspin/recorder.rb

@@ -1,221 +1,91 @@
 # frozen_string_literal: true
 
-require "open3"
-require "ostruct"
-require "rspec/mocks"
-require "backspin/command_result"
+require "tempfile"
 require "backspin/command_diff"
 
 module Backspin
-  # Handles stubbing and recording of command executions
+  # Handles capture-mode recording and verification
   class Recorder
-    include RSpec::Mocks::ExampleMethods
-    SUPPORTED_COMMAND_TYPES = %i[capture3 system].freeze
-
-    attr_reader :commands, :mode, :record, :matcher, :filter
+    attr_reader :mode, :record, :matcher, :filter
 
     def initialize(mode: :record, record: nil, matcher: nil, filter: nil)
       @mode = mode
       @record = record
       @matcher = matcher
       @filter = filter
-      @commands = []
-      @playback_index = 0
-      @command_diffs = []
-    end
-
-    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
     end
 
-    def record_call(command_type)
-      case command_type
-      when :system
-        setup_system_call_stub
-      when :capture3
-        setup_capture3_call_stub
-      else
-        raise ArgumentError,
-          "Unsupported command type: #{command_type} - currently supported types: #{SUPPORTED_COMMAND_TYPES.join(", ")}"
-      end
-    end
+    # Performs capture recording by intercepting all stdout/stderr output
+    def perform_capture_recording
+      captured_stdout, captured_stderr, output = capture_output { yield }
+
+      command = Command.new(
+        method_class: Backspin::Capturer,
+        args: ["<captured block>"],
+        stdout: captured_stdout,
+        stderr: captured_stderr,
+        status: 0,
+        recorded_at: Time.now.iso8601
+      )
 
-    # Records registered commands, adds them to the record, saves the record, and returns the overall RecordResult
-    def perform_recording
-      result = yield
+      record.add_command(command)
       record.save(filter: @filter)
-      RecordResult.new(output: result, mode: :record, record: record)
+
+      RecordResult.new(output: output, mode: :record, record: record)
     end
 
-    # Performs verification by executing commands and comparing with recorded values
-    def perform_verification
+    # Performs capture verification by capturing output and comparing with recorded values
+    def perform_capture_verification
       raise RecordNotFoundError, "Record not found: #{record.path}" unless record.exists?
       raise RecordNotFoundError, "No commands found in record #{record.path}" if record.empty?
-
-      # Initialize tracking variables
-      @command_diffs = []
-      @command_index = 0
-
-      # 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: @matcher)
-        @command_index += 1
-        [stdout, stderr, status]
+      if record.commands.size != 1
+        raise RecordFormatError, "Invalid record format: expected 1 command for capture, found #{record.commands.size}"
       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: @matcher)
-
-        @command_index += 1
-        result
+      recorded_command = record.commands.first
+      unless recorded_command.method_class == Backspin::Capturer
+        raise RecordFormatError, "Invalid record format: expected Backspin::Capturer for capture"
       end
 
-      output = yield
-
-      all_verified = @command_diffs.all?(&:verified?)
+      captured_stdout, captured_stderr, output = capture_output { yield }
 
-      RecordResult.new(
-        output: output,
-        mode: :verify,
-        verified: all_verified,
-        record: record,
-        command_diffs: @command_diffs
+      actual_command = Command.new(
+        method_class: Backspin::Capturer,
+        args: ["<captured block>"],
+        stdout: captured_stdout,
+        stderr: captured_stderr,
+        status: 0
       )
-    end
 
-    # 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
+      command_diff = CommandDiff.new(
+        recorded_command: recorded_command,
+        actual_command: actual_command,
+        matcher: @matcher
+      )
 
       RecordResult.new(
         output: output,
-        mode: :playback,
-        verified: true, # Always true for playback
-        record: record
+        mode: :verify,
+        verified: command_diff.verified?,
+        record: record,
+        command_diffs: [command_diff]
       )
     end
 
-    # Performs capture recording by intercepting all stdout/stderr output
-    def perform_capture_recording
-      require "tempfile"
-
-      # Create temporary files for capturing output
-      stdout_tempfile = Tempfile.new("backspin_stdout")
-      stderr_tempfile = Tempfile.new("backspin_stderr")
-
-      begin
-        # Save original file descriptors
-        original_stdout_fd = $stdout.dup
-        original_stderr_fd = $stderr.dup
-
-        # Redirect both Ruby IO and file descriptors
-        $stdout.reopen(stdout_tempfile)
-        $stderr.reopen(stderr_tempfile)
-
-        # Execute the block
-        result = yield
-
-        # Flush and read captured output
-        $stdout.flush
-        $stderr.flush
-        stdout_tempfile.rewind
-        stderr_tempfile.rewind
-
-        captured_stdout = stdout_tempfile.read
-        captured_stderr = stderr_tempfile.read
-
-        # Create a single command representing all captured output
-        command = Command.new(
-          method_class: Backspin::Capturer,
-          args: ["<captured block>"],
-          stdout: captured_stdout,
-          stderr: captured_stderr,
-          status: 0,
-          recorded_at: Time.now.iso8601
-        )
-
-        record.add_command(command)
-        record.save(filter: @filter)
-
-        RecordResult.new(output: result, mode: :record, record: record)
-      ensure
-        # Restore original file descriptors
-        $stdout.reopen(original_stdout_fd)
-        $stderr.reopen(original_stderr_fd)
-        original_stdout_fd.close
-        original_stderr_fd.close
-
-        # Clean up temp files
-        stdout_tempfile.close!
-        stderr_tempfile.close!
-      end
-    end
-
-    # Performs capture verification by capturing output and comparing with recorded values
-    def perform_capture_verification
-      raise RecordNotFoundError, "Record not found: #{record.path}" unless record.exists?
-      raise RecordNotFoundError, "No commands found in record #{record.path}" if record.empty?
-
-      require "tempfile"
+    private
 
-      # Create temporary files for capturing output
+    def capture_output
       stdout_tempfile = Tempfile.new("backspin_stdout")
       stderr_tempfile = Tempfile.new("backspin_stderr")
+      original_stdout_fd = $stdout.dup
+      original_stderr_fd = $stderr.dup
 
       begin
-        # Save original file descriptors
-        original_stdout_fd = $stdout.dup
-        original_stderr_fd = $stderr.dup
-
-        # Redirect both Ruby IO and file descriptors
         $stdout.reopen(stdout_tempfile)
         $stderr.reopen(stderr_tempfile)
 
-        # Execute the block
         output = yield
 
-        # Flush and read captured output
         $stdout.flush
         $stderr.flush
         stdout_tempfile.rewind
@@ -224,141 +94,16 @@ module Backspin
         captured_stdout = stdout_tempfile.read
         captured_stderr = stderr_tempfile.read
 
-        # Get the recorded command (should be only one for capture)
-        recorded_command = record.commands.first
-
-        # Create actual command from captured output
-        actual_command = Command.new(
-          method_class: Backspin::Capturer,
-          args: ["<captured block>"],
-          stdout: captured_stdout,
-          stderr: captured_stderr,
-          status: 0
-        )
-
-        # Create CommandDiff for comparison
-        command_diff = CommandDiff.new(
-          recorded_command: recorded_command,
-          actual_command: actual_command,
-          matcher: @matcher
-        )
-
-        RecordResult.new(
-          output: output,
-          mode: :verify,
-          verified: command_diff.verified?,
-          record: record,
-          command_diffs: [command_diff]
-        )
+        [captured_stdout, captured_stderr, output]
       ensure
-        # Restore original file descriptors
         $stdout.reopen(original_stdout_fd)
         $stderr.reopen(original_stderr_fd)
         original_stdout_fd.close
         original_stderr_fd.close
 
-        # Clean up temp files
         stdout_tempfile.close!
         stderr_tempfile.close!
       end
     end
-
-    # Performs capture playback - executes block normally but could optionally suppress output
-    def perform_capture_playback
-      raise RecordNotFoundError, "Record not found: #{record.path}" unless record.exists?
-      raise RecordNotFoundError, "No commands found in record" if record.empty?
-
-      # For now, just execute the block normally
-      # In the future, we could optionally suppress output or return recorded output
-      output = yield
-
-      RecordResult.new(
-        output: output,
-        mode: :playback,
-        verified: true,
-        record: record
-      )
-    end
-
-    private
-
-    def setup_capture3_replay_stub
-      allow(Open3).to receive(:capture3) do |*_args|
-        command = @record.next_command
-
-        recorded_stdout = command.stdout
-        recorded_stderr = command.stderr
-        recorded_status = OpenStruct.new(exitstatus: command.status)
-
-        [recorded_stdout, recorded_stderr, recorded_status]
-      rescue NoMoreRecordingsError => e
-        raise RecordNotFoundError, e.message
-      end
-    end
-
-    def setup_system_replay_stub
-      allow_any_instance_of(Object).to receive(:system) do |_receiver, *_args|
-        command = @record.next_command
-
-        command.status.zero?
-      rescue NoMoreRecordingsError => e
-        raise RecordNotFoundError, e.message
-      end
-    end
-
-    def setup_capture3_call_stub
-      allow(Open3).to receive(:capture3).and_wrap_original do |original_method, *args|
-        stdout, stderr, status = original_method.call(*args)
-
-        cmd_args = if args.length == 1 && args.first.is_a?(String)
-          args.first.split(" ")
-        else
-          args
-        end
-
-        command = Command.new(
-          method_class: Open3::Capture3,
-          args: cmd_args,
-          stdout: stdout,
-          stderr: stderr,
-          status: status.exitstatus,
-          recorded_at: Time.now.iso8601
-        )
-        record.add_command(command)
-
-        [stdout, stderr, status]
-      end
-    end
-
-    def setup_system_call_stub
-      allow_any_instance_of(Object).to receive(:system).and_wrap_original do |original_method, receiver, *args|
-        result = original_method.call(receiver, *args)
-
-        # Parse command args based on how system was called
-        parsed_args = if args.empty? && receiver.is_a?(String)
-          # Single string form - split the command string
-          receiver.split(" ")
-        else
-          # Multi-arg form - already an array
-          args
-        end
-
-        stdout = ""
-        stderr = ""
-        status = result ? 0 : 1
-
-        command = Command.new(
-          method_class: ::Kernel::System,
-          args: parsed_args,
-          stdout: stdout,
-          stderr: stderr,
-          status: status,
-          recorded_at: Time.now.iso8601
-        )
-        record.add_command(command)
-
-        result
-      end
-    end
   end
 end

data/lib/backspin/version.rb

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