`class Socket`

A transparent socket wrapper that automatically manages token release. Behaves exactly like the wrapped socket but releases the limiter token on close.

Definitions

`def initialize(delegate, token)`

Initialize the socket wrapper with delegation and token management.

Signature

parameter　delegate　Object: The socket object to wrap and delegate to.
parameter　token　Async::Limiter::Token: The limiter token to release when socket closes.

Implementation

def initialize(delegate, token)
	@delegate = delegate
	@token = token
end

`attr_reader :token`

Provide access to the token for manual management if needed.

`def close`

Override close to release the token.

Implementation

def close
	@delegate.close
ensure
	if token = @token
		@token = nil
		token.release
	end
end

`def method_missing(...)`

Transparent delegation to the wrapped delegate.

Implementation

def method_missing(...)
	@delegate.public_send(...)
end

`def respond_to?(method, include_private = false)`

Check if this wrapper or the delegate responds to a method.

Signature

parameter　method　Symbol: The method name to check.
parameter　include_private　Boolean: Whether to include private methods (default: false).
returns　Boolean: True if either wrapper or delegate responds to the method.

Implementation

def respond_to?(method, include_private = false)
	# Check our own methods first (token, close, inspect, to_s, etc.)
	case method.to_sym
	when :token
		true
	else
		# Check delegate for other methods
		@delegate.respond_to?(method, include_private)
	end
end

`def inspect`

Forward common inspection methods

Implementation

def inspect
	"#<#{Socket} #{@delegate.inspect}>"
end

`def to_s`

String representation of the wrapped socket.

Signature

returns　String: The string representation of the delegate socket.

Implementation

def to_s
	@delegate.to_s
end