# PSR-7 Message Implementation

This repository contains a full [PSR-7](http://www.php-fig.org/psr/psr-7/) message implementation, several stream decorators, and some helpful functionality like query string parsing. [](https://travis-ci.org/guzzle/psr7) # Stream implementation This package comes with a number of stream implementations and stream decorators. ## AppendStream `GuzzleHttpPsr7AppendStream` Reads from multiple streams, one after the other. ```php use GuzzleHttpPsr7; $a = Psr7stream_for('abc, '); $b = Psr7stream_for('123.'); $composed = new Psr7AppendStream([$a, $b]); $composed->addStream(Psr7stream_for(' Above all listen to me')); echo $composed; // abc, 123. Above all listen to me. ``` ## BufferStream `GuzzleHttpPsr7BufferStream` Provides a buffer stream that can be written to fill a buffer, and read from to remove bytes from the buffer. This stream returns a "hwm" metadata value that tells upstream consumers what the configured high water mark of the stream is, or the maximum preferred size of the buffer. ```php use GuzzleHttpPsr7; // When more than 1024 bytes are in the buffer, it will begin returning // false to writes. This is an indication that writers should slow down. $buffer = new Psr7BufferStream(1024); ``` ## CachingStream The CachingStream is used to allow seeking over previously read bytes on non-seekable streams. This can be useful when transferring a non-seekable entity body fails due to needing to rewind the stream (for example, resulting from a redirect). Data that is read from the remote stream will be buffered in a PHP temp stream so that previously read bytes are cached first in memory, then on disk. ```php use GuzzleHttpPsr7; $original = Psr7stream_for(fopen('http://www.google.com', 'r')); $stream = new Psr7CachingStream($original); $stream->read(1024); echo $stream->tell(); // 1024 $stream->seek(0); echo $stream->tell(); // 0 ``` ## DroppingStream `GuzzleHttpPsr7DroppingStream` Stream decorator that begins dropping data once the size of the underlying stream becomes too full. ```php use GuzzleHttpPsr7; // Create an empty stream $stream = Psr7stream_for(); // Start dropping data when the stream has more than 10 bytes $dropping = new Psr7DroppingStream($stream, 10); $dropping->write('01234567890123456789'); echo $stream; // 0123456789 ``` ## FnStream `GuzzleHttpPsr7FnStream` Compose stream implementations based on a hash of functions. Allows for easy testing and extension of a provided stream without needing to create a concrete class for a simple extension point. ```php use GuzzleHttpPsr7; $stream = Psr7stream_for('hi'); $fnStream = Psr7FnStream::decorate($stream, [ 'rewind' => function () use ($stream) { echo 'about to rewind - '; $stream->rewind(); echo 'rewound!'; } ]); $fnStream->rewind(); // Outputs: about to rewind - rewound! ``` ## InflateStream `GuzzleHttpPsr7InflateStream` Uses PHP's zlib.inflate filter to inflate deflate or gzipped content. This stream decorator skips the first 10 bytes of the given stream to remove the gzip header, converts the provided stream to a PHP stream resource, then appends the zlib.inflate filter. The stream is then converted back to a Guzzle stream resource to be used as a Guzzle stream. ## LazyOpenStream `GuzzleHttpPsr7LazyOpenStream` Lazily reads or writes to a file that is opened only after an IO operation take place on the stream. ```php use GuzzleHttpPsr7; $stream = new Psr7LazyOpenStream('/path/to/file', 'r'); // The file has not yet been opened... echo $stream->read(10); // The file is opened and read from only when needed. ``` ## LimitStream `GuzzleHttpPsr7LimitStream` LimitStream can be used to read a subset or slice of an existing stream object. This can be useful for breaking a large file into smaller pieces to be sent in chunks (e.g. Amazon S3's multipart upload API). ```php use GuzzleHttpPsr7; $original = Psr7stream_for(fopen('/tmp/test.txt', 'r+')); echo $original->getSize(); // >>> 1048576 // Limit the size of the body to 1024 bytes and start reading from byte 2048 $stream = new Psr7LimitStream($original, 1024, 2048); echo $stream->getSize(); // >>> 1024 echo $stream->tell(); // >>> 0 ``` ## MultipartStream `GuzzleHttpPsr7MultipartStream` Stream that when read returns bytes for a streaming multipart or multipart/form-data stream. ## NoSeekStream `GuzzleHttpPsr7NoSeekStream` NoSeekStream wraps a stream and does not allow seeking. ```php use GuzzleHttpPsr7; $original = Psr7stream_for('foo'); $noSeek = new Psr7NoSeekStream($original); echo $noSeek->read(3); // foo var_export($noSeek->isSeekable()); // false $noSeek->seek(0); var_export($noSeek->read(3)); // NULL ``` ## PumpStream `GuzzleHttpPsr7PumpStream` Provides a read only stream that pumps data from a PHP callable. When invoking the provided callable, the PumpStream will pass the amount of data requested to read to the callable. The callable can choose to ignore this value and return fewer or more bytes than requested. Any extra data returned by the provided callable is buffered internally until drained using the read() function of the PumpStream. The provided callable MUST return false when there is no more data to read. ## Implementing stream decorators Creating a stream decorator is very easy thanks to the `GuzzleHttpPsr7StreamDecoratorTrait`. This trait provides methods that implement `PsrHttpMessageStreamInterface` by proxying to an underlying stream. Just `use` the `StreamDecoratorTrait` and implement your custom methods. For example, let's say we wanted to call a specific function each time the last byte is read from a stream. This could be implemented by overriding the `read()` method. ```php use PsrHttpMessageStreamInterface; use GuzzleHttpPsr7StreamDecoratorTrait; class EofCallbackStream implements StreamInterface { use StreamDecoratorTrait; private $callback; public function __construct(StreamInterface $stream, callable $cb) { $this->stream = $stream; $this->callback = $cb; } public function read($length) { $result = $this->stream->read($length); // Invoke the callback when EOF is hit. if ($this->eof()) { call_user_func($this->callback); } return $result; } } ``` This decorator could be added to any existing stream and used like so: ```php use GuzzleHttpPsr7; $original = Psr7stream_for('foo'); $eofStream = new EofCallbackStream($original, function () { echo 'EOF!'; }); $eofStream->read(2); $eofStream->read(1); // echoes "EOF!" $eofStream->seek(0); $eofStream->read(3); // echoes "EOF!" ``` ## PHP StreamWrapper You can use the `GuzzleHttpPsr7StreamWrapper` class if you need to use a PSR-7 stream as a PHP stream resource. Use the `GuzzleHttpPsr7StreamWrapper::getResource()` method to create a PHP stream from a PSR-7 stream. ```php use GuzzleHttpPsr7StreamWrapper; $stream = GuzzleHttpPsr7stream_for('hello!'); $resource = StreamWrapper::getResource($stream); echo fread($resource, 6); // outputs hello! ``` # Function API There are various functions available under the `GuzzleHttpPsr7` namespace. ## `function str` `function str(MessageInterface $message)` Returns the string representation of an HTTP message. ```php $request = new GuzzleHttpPsr7Request('GET', 'http://example.com'); echo GuzzleHttpPsr7str($request); ``` ## `function uri_for` `function uri_for($uri)` This function accepts a string or `PsrHttpMessageUriInterface` and returns a UriInterface for the given value. If the value is already a `UriInterface`, it is returned as-is. ```php $uri = GuzzleHttpPsr7or('http://example.com'); assert($uri === GuzzleHttpPsr7or($uri)); ``` ## `function stream_for`