backspin 0.8.0 → 0.10.0

data/lib/backspin/matcher.rb

@@ -1,63 +1,24 @@
 # frozen_string_literal: true
 
 module Backspin
-  # Handles matching logic between recorded and actual commands
+  # Handles matching logic between expected and actual snapshots.
   class Matcher
-    attr_reader :config, :recorded_command, :actual_command
+    attr_reader :config, :expected, :actual
 
-    def initialize(config:, recorded_command:, actual_command:)
+    def initialize(config:, expected:, actual:)
       @config = normalize_config(config)
-      @recorded_command = recorded_command
-      @actual_command = actual_command
+      @expected = expected
+      @actual = actual
     end
 
-    # @return [Boolean] true if commands match according to the configured matcher
+    # @return [Boolean] true if snapshots match according to configured matcher
     def match?
-      if config.nil?
-        # Default behavior: check all fields for equality
-        default_matcher.call(recorded_command.to_h, actual_command.to_h)
-      elsif config.is_a?(Proc)
-        config.call(recorded_command.to_h, actual_command.to_h)
-      elsif config.is_a?(Hash)
-        verify_with_hash_matcher
-      else
-        raise ArgumentError, "Invalid matcher type: #{config.class}"
-      end
+      evaluation[:match]
     end
 
     # @return [String] reason why matching failed
     def failure_reason
-      reasons = []
-
-      if config.nil?
-        # Default matcher checks all fields
-        recorded_hash = recorded_command.to_h
-        actual_hash = actual_command.to_h
-
-        reasons << "stdout differs" if recorded_hash["stdout"] != actual_hash["stdout"]
-        reasons << "stderr differs" if recorded_hash["stderr"] != actual_hash["stderr"]
-        reasons << "exit status differs" if recorded_hash["status"] != actual_hash["status"]
-      elsif config.is_a?(Hash)
-        recorded_hash = recorded_command.to_h
-        actual_hash = actual_command.to_h
-
-        # Only check matchers that were provided
-        config.each do |field, matcher_proc|
-          case field
-          when :all
-            reasons << ":all matcher failed" unless matcher_proc.call(recorded_hash, actual_hash)
-          when :stdout, :stderr, :status
-            unless matcher_proc.call(recorded_hash[field.to_s], actual_hash[field.to_s])
-              reasons << "#{field} custom matcher failed"
-            end
-          end
-        end
-      else
-        # Proc matcher
-        reasons << "custom matcher failed"
-      end
-
-      reasons.join(", ")
+      evaluation[:reason]
     end
 
     private
@@ -78,32 +39,73 @@ module Backspin
       config
     end
 
-    def verify_with_hash_matcher
-      recorded_hash = recorded_command.to_h
-      actual_hash = actual_command.to_h
+    def evaluation
+      @evaluation ||= if config.nil?
+        evaluate_default
+      elsif config.is_a?(Proc)
+        evaluate_proc
+      elsif config.is_a?(Hash)
+        evaluate_hash
+      else
+        raise ArgumentError, "Invalid matcher type: #{config.class}"
+      end
+    end
+
+    def evaluate_default
+      reasons = []
+      reasons << "stdout differs" if expected.stdout != actual.stdout
+      reasons << "stderr differs" if expected.stderr != actual.stderr
+      reasons << "exit status differs" if expected.status != actual.status
 
-      # Override-based: only run matchers that are explicitly provided
-      # Use map to ensure all matchers run, then check if all passed
-      results = config.map do |field, matcher_proc|
-        case field
+      {match: reasons.empty?, reason: reasons.join(", ")}
+    end
+
+    def evaluate_proc
+      match = !!config.call(deep_dup(expected_hash), deep_dup(actual_hash))
+      reason = match ? "" : "custom matcher failed"
+      {match: match, reason: reason}
+    end
+
+    def evaluate_hash
+      reasons = []
+
+      config.each do |field, matcher_proc|
+        passed = case field
         when :all
-          matcher_proc.call(recorded_hash, actual_hash)
+          matcher_proc.call(deep_dup(expected_hash), deep_dup(actual_hash))
         when :stdout, :stderr, :status
-          matcher_proc.call(recorded_hash[field.to_s], actual_hash[field.to_s])
+          matcher_proc.call(deep_dup(expected.public_send(field)), deep_dup(actual.public_send(field)))
         else
-          # This should never happen due to normalize_config validation
           raise ArgumentError, "Unknown field: #{field}"
         end
+
+        next if passed
+
+        reasons << ":all matcher failed" if field == :all
+        reasons << "#{field} custom matcher failed" if %i[stdout stderr status].include?(field)
       end
 
-      results.all?
+      {match: reasons.empty?, reason: reasons.join(", ")}
+    end
+
+    def expected_hash
+      @expected_hash ||= expected.to_h
+    end
+
+    def actual_hash
+      @actual_hash ||= actual.to_h
     end
 
-    def default_matcher
-      @default_matcher ||= lambda do |recorded, actual|
-        recorded["stdout"] == actual["stdout"] &&
-          recorded["stderr"] == actual["stderr"] &&
-          recorded["status"] == actual["status"]
+    def deep_dup(value)
+      case value
+      when Hash
+        value.transform_values { |entry| deep_dup(entry) }
+      when Array
+        value.map { |entry| deep_dup(entry) }
+      when String
+        value.dup
+      else
+        value
       end
     end
   end

data/lib/backspin/record.rb

@@ -4,8 +4,8 @@ module Backspin
   class RecordFormatError < StandardError; end
 
   class Record
-    FORMAT_VERSION = "3.0"
-    attr_reader :path, :commands, :first_recorded_at
+    FORMAT_VERSION = "4.0"
+    attr_reader :path, :snapshot, :recorded_at
 
     def self.load_or_create(path)
       record = new(path)
@@ -35,28 +35,31 @@ module Backspin
 
     def initialize(path)
       @path = path
-      @commands = []
-      @first_recorded_at = nil
+      @snapshot = nil
+      @recorded_at = nil
     end
 
-    def add_command(command)
-      @commands << command
-      @first_recorded_at ||= command.recorded_at
+    def set_snapshot(snapshot)
+      @snapshot = snapshot
+      @recorded_at ||= snapshot.recorded_at
       self
     end
 
     def save(filter: nil)
       FileUtils.mkdir_p(File.dirname(@path))
+      snapshot_data = @snapshot&.to_h
+      snapshot_data = filter.call(deep_dup(snapshot_data)) if snapshot_data && filter
       record_data = {
-        "first_recorded_at" => @first_recorded_at,
         "format_version" => FORMAT_VERSION,
-        "commands" => @commands.map { |cmd| cmd.to_h(filter: filter) }
+        "recorded_at" => @recorded_at,
+        "snapshot" => snapshot_data
       }
       File.write(@path, record_data.to_yaml)
     end
 
     def reload
-      @commands = []
+      @snapshot = nil
+      @recorded_at = nil
       load_from_file if File.exist?(@path)
     end
 
@@ -65,19 +68,14 @@ module Backspin
     end
 
     def empty?
-      @commands.empty?
-    end
-
-    def size
-      @commands.size
+      @snapshot.nil?
     end
 
     def clear
-      @commands = []
+      @snapshot = nil
+      @recorded_at = nil
     end
 
-    # private
-
     def load_from_file
       data = YAML.load_file(@path.to_s)
 
@@ -85,15 +83,30 @@ module Backspin
         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"
+      snapshot_data = data["snapshot"]
+      unless snapshot_data.is_a?(Hash)
+        raise RecordFormatError, "Invalid record format: missing snapshot"
       end
 
-      @first_recorded_at = data["first_recorded_at"]
-      @commands = commands.map { |command_data| Command.from_h(command_data) }
+      @recorded_at = data["recorded_at"]
+      @snapshot = Snapshot.from_h(snapshot_data)
     rescue Psych::SyntaxError => e
       raise RecordFormatError, "Invalid record format: #{e.message}"
     end
+
+    private
+
+    def deep_dup(value)
+      case value
+      when Hash
+        value.transform_values { |entry| deep_dup(entry) }
+      when Array
+        value.map { |entry| deep_dup(entry) }
+      when String
+        value.dup
+      else
+        value
+      end
+    end
   end
 end

data/lib/backspin/recorder.rb

@@ -6,21 +6,22 @@ require "backspin/command_diff"
 module Backspin
   # Handles capture-mode recording and verification
   class Recorder
-    attr_reader :mode, :record, :matcher, :filter
+    attr_reader :mode, :record, :matcher, :filter, :filter_on
 
-    def initialize(mode: :record, record: nil, matcher: nil, filter: nil)
+    def initialize(mode: :record, record: nil, matcher: nil, filter: nil, filter_on: :both)
       @mode = mode
       @record = record
       @matcher = matcher
       @filter = filter
+      @filter_on = filter_on
     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,
+      actual_snapshot = Snapshot.new(
+        command_type: Backspin::Capturer,
         args: ["<captured block>"],
         stdout: captured_stdout,
         stderr: captured_stderr,
@@ -28,29 +29,31 @@ module Backspin
         recorded_at: Time.now.iso8601
       )
 
-      record.add_command(command)
+      record.set_snapshot(actual_snapshot)
       record.save(filter: @filter)
 
-      RecordResult.new(output: output, mode: :record, record: record)
+      BackspinResult.new(
+        mode: :record,
+        record_path: record.path,
+        actual: actual_snapshot,
+        output: output
+      )
     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?
-      if record.commands.size != 1
-        raise RecordFormatError, "Invalid record format: expected 1 command for capture, found #{record.commands.size}"
-      end
+      raise RecordNotFoundError, "No snapshot found in record #{record.path}" if record.empty?
 
-      recorded_command = record.commands.first
-      unless recorded_command.method_class == Backspin::Capturer
+      expected_snapshot = record.snapshot
+      unless expected_snapshot.command_type == Backspin::Capturer
         raise RecordFormatError, "Invalid record format: expected Backspin::Capturer for capture"
       end
 
       captured_stdout, captured_stderr, output = capture_output { yield }
 
-      actual_command = Command.new(
-        method_class: Backspin::Capturer,
+      actual_snapshot = Snapshot.new(
+        command_type: Backspin::Capturer,
         args: ["<captured block>"],
         stdout: captured_stdout,
         stderr: captured_stderr,
@@ -58,17 +61,21 @@ module Backspin
       )
 
       command_diff = CommandDiff.new(
-        recorded_command: recorded_command,
-        actual_command: actual_command,
-        matcher: @matcher
+        expected: expected_snapshot,
+        actual: actual_snapshot,
+        matcher: @matcher,
+        filter: @filter,
+        filter_on: @filter_on
       )
 
-      RecordResult.new(
-        output: output,
+      BackspinResult.new(
         mode: :verify,
+        record_path: record.path,
+        actual: actual_snapshot,
+        expected: expected_snapshot,
         verified: command_diff.verified?,
-        record: record,
-        command_diffs: [command_diff]
+        command_diff: command_diff,
+        output: output
       )
     end
 

data/lib/backspin/snapshot.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Backspin
+  # Represents a single captured execution snapshot.
+  class Snapshot
+    attr_reader :command_type, :args, :env, :stdout, :stderr, :status, :recorded_at
+
+    def initialize(command_type:, args:, env: nil, stdout: "", stderr: "", status: 0, recorded_at: nil)
+      @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
+      @status = status || 0
+      @recorded_at = recorded_at.nil? ? nil : recorded_at.dup.freeze
+      @serialized_hash = build_serialized_hash
+    end
+
+    def success?
+      status.zero?
+    end
+
+    def failure?
+      !success?
+    end
+
+    def to_h
+      @serialized_hash
+    end
+
+    def self.from_h(data)
+      command_type = case data["command_type"]
+      when "Open3::Capture3"
+        Open3::Capture3
+      when "Backspin::Capturer"
+        Backspin::Capturer
+      else
+        raise RecordFormatError, "Unknown command type: #{data["command_type"]}"
+      end
+
+      new(
+        command_type: command_type,
+        args: data["args"],
+        env: data["env"],
+        stdout: data["stdout"],
+        stderr: data["stderr"],
+        status: data["status"],
+        recorded_at: data["recorded_at"]
+      )
+    end
+
+    private
+
+    def build_serialized_hash
+      data = {
+        "command_type" => command_type.name,
+        "args" => args,
+        "stdout" => stdout,
+        "stderr" => stderr,
+        "status" => status,
+        "recorded_at" => recorded_at
+      }
+      data["env"] = env if env
+      deep_freeze(data)
+    end
+
+    def scrub_args(value)
+      return value unless Backspin.configuration.scrub_credentials && value
+
+      case value
+      when String
+        Backspin.scrub_text(value)
+      when Array
+        value.map { |entry| scrub_args(entry) }
+      when Hash
+        value.transform_values { |entry| entry.is_a?(String) ? Backspin.scrub_text(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 }
+    end
+
+    def sanitize_args(value)
+      deep_freeze(scrub_args(deep_dup(value)))
+    end
+
+    def sanitize_env(value)
+      deep_freeze(scrub_env(deep_dup(value)))
+    end
+
+    def deep_freeze(value)
+      case value
+      when Hash
+        value.each_value { |v| deep_freeze(v) }
+      when Array
+        value.each { |v| deep_freeze(v) }
+      end
+      value.freeze
+    end
+
+    def deep_dup(value)
+      case value
+      when Hash
+        value.transform_values { |entry| deep_dup(entry) }
+      when Array
+        value.map { |entry| deep_dup(entry) }
+      when String
+        value.dup
+      else
+        value
+      end
+    end
+  end
+end
+
+# Define the Open3::Capture3 class for identification.
+module Open3
+  class Capture3; end
+end
+
+# Define the Backspin::Capturer class for identification.
+module Backspin
+  class Capturer; end
+end

data/lib/backspin/version.rb

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