`module Environment`

A flat environment module for HTTP capture services.

Provides simple, declarative configuration for recording and replaying HTTP interactions. Override these methods in your service to customize behavior.

Definitions

`def capture_cassette_directory`

Directory path to load cassettes from for replay warmup. Override this method to specify a different directory.

Implementation

def capture_cassette_directory
	"cassette/warmup"
end

`def capture_recordings_directory`

Directory path to save recordings to. Override this method to specify where recordings should be saved.

Implementation

def capture_recordings_directory
	"cassette/recordings"
end

`def capture_console_logging`

Whether to enable console logging of interactions (default: false). Override this method to enable console output.

Implementation

def capture_console_logging
	true
end

`def capture_cassette`

Load the cassette for replay if configured

Implementation

def capture_cassette
	if capture_cassette_directory && File.directory?(capture_cassette_directory)
		Cassette.load(capture_cassette_directory)
	end
end

`def capture_recording_store`

Get the recording store if configured

Implementation

def capture_recording_store
	stores = []
	
	# Add file storage if directory configured
	if capture_recordings_directory
		stores << CassetteStore.new(capture_recordings_directory)
	end
	
	# Add console logging if enabled
	if capture_console_logging
		stores << ConsoleStore.new
	end
	
	# Return combined store or nil
	case stores.length
	when 0
		nil
	when 1
		stores.first
	else
		# Multiple stores - combine them
		proc do |interaction|
			stores.each {|store| store.call(interaction)}
		end
	end
end

`def capture_middleware_class`

The middleware class to use for recording.

Implementation

def capture_middleware_class
	Middleware
end

`def capture_middleware(middleware)`

Wrap the middleware with the recording middleware.

Signature

parameter　middleware　Middleware: The middleware to wrap.
parameter　store　CassetteStore: The store to use for recording.
returns　Middleware: The wrapped middleware.

Implementation

def capture_middleware(middleware)
	if store = capture_recording_store
		middleware = capture_middleware_class.new(middleware, store: store)
	end
	
	return middleware
end

`def middleware`

Set up middleware chain with recording support.

Implementation

def middleware
	# Get the underlying application by calling super:
	middleware = super
	
	# Warm up the application with recorded interactions if available:
	capture_cassette&.replay(middleware)
	
	# Wrap with recording middleware if store is configured
	return capture_middleware(middleware)
end