clue/stream-filter

A simple and modern approach to stream filtering in PHP

Table of contents

• Why?
• Support us
• Usage
  • append()
  • prepend()
  • fun()
  • remove()
• Install
• Tests
• License

Why?

PHP’s stream filtering system is great!

It offers very powerful stream filtering options and comes with a useful set of built-in filters.
These filters can be used to easily and efficiently perform various transformations on-the-fly, such as:

• read from a gzip’ed input file,
• transcode from ISO-8859-1 (Latin1) to UTF-8,
• write to a bzip output file
• and much more.

But let’s face it:
Its API is difficult to work with
and its documentation is subpar.
This combined means its powerful features are often neglected.

This project aims to make these features more accessible to a broader audience.

• Lightweight, SOLID design -
  Provides a thin abstraction that is just good enough
  and does not get in your way.
  Custom filters require trivial effort.
• Good test coverage -
  Comes with an automated tests suite and is regularly tested in the real world

Support us

We invest a lot of time developing, maintaining and updating our awesome
open-source projects. You can help us sustain this high-quality of our work by
becoming a sponsor on GitHub. Sponsors get
numerous benefits in return, see our sponsoring page
for details.

Let’s take these projects to the next level together! 🚀

Usage

This lightweight library consists only of a few simple functions.
All functions reside under the Clue\StreamFilter namespace.

The below examples refer to all functions with their fully-qualified names like this:

Clue\StreamFilter\append(…);

As of PHP 5.6+ you can also import each required function into your code like this:

use function Clue\StreamFilter\append;

append(…);

Alternatively, you can also use an import statement similar to this:

use Clue\StreamFilter as Filter;

Filter\append(…);

append()

The append(resource<stream> $stream, callable $callback, int $read_write = STREAM_FILTER_ALL): resource<stream filter> function can be used to
append a filter callback to the given stream.

Each stream can have a list of filters attached.
This function appends a filter to the end of this list.

If the given filter can not be added, it throws an Exception.

The $stream can be any valid stream resource, such as:

$stream = fopen('demo.txt', 'w+');

The $callback should be a valid callable function which accepts
an individual chunk of data and should return the updated chunk:

$filter = Clue\StreamFilter\append($stream, function ($chunk) {
    // will be called each time you read or write a $chunk to/from the stream
    return $chunk;
});

As such, you can also use native PHP functions or any other callable:

Clue\StreamFilter\append($stream, 'strtoupper');

// will write "HELLO" to the underlying stream
fwrite($stream, 'hello');

If the $callback accepts invocation without parameters,
then this signature will be invoked once ending (flushing) the filter:

Clue\StreamFilter\append($stream, function ($chunk = null) {
    if ($chunk === null) {
        // will be called once ending the filter
        return 'end';
    }
    // will be called each time you read or write a $chunk to/from the stream
    return $chunk;
});

fclose($stream);

Note: Legacy PHP versions (PHP < 5.4) do not support passing additional data
from the end signal handler if the stream is being closed.

If your callback throws an Exception, then the filter process will be aborted.
In order to play nice with PHP’s stream handling,
the Exception will be transformed to a PHP warning instead:

Clue\StreamFilter\append($stream, function ($chunk) {
    throw new \RuntimeException('Unexpected chunk');
});

// raises an E_USER_WARNING with "Error invoking filter: Unexpected chunk"
fwrite($stream, 'hello');

The optional $read_write parameter can be used to only invoke the $callback
when either writing to the stream or only when reading from the stream:

Clue\StreamFilter\append($stream, function ($chunk) {
    // will be called each time you write to the stream
    return $chunk;
}, STREAM_FILTER_WRITE);

Clue\StreamFilter\append($stream, function ($chunk) {
    // will be called each time you read from the stream
    return $chunk;
}, STREAM_FILTER_READ);

This function returns a filter resource which can be passed to remove().

Note that once a filter has been added to stream, the stream can no longer be passed to
stream_select()
(and family).

Warning: stream_select(): cannot cast a filtered stream on this system in {file} on line {line}

This is due to limitations of PHP’s stream filter support, as it can no longer reliably
tell when the underlying stream resource is actually ready.
As an alternative, consider calling stream_select() on the unfiltered stream and
then pass the unfiltered data through the fun() function.

prepend()

The prepend(resource<stream> $stream, callable $callback, int $read_write = STREAM_FILTER_ALL): resource<stream filter> function can be used to
prepend a filter callback to the given stream.

Each stream can have a list of filters attached.
This function prepends a filter to the start of this list.

If the given filter can not be added, it throws an Exception.

$filter = Clue\StreamFilter\prepend($stream, function ($chunk) {
    // will be called each time you read or write a $chunk to/from the stream
    return $chunk;
});

This function returns a filter resource which can be passed to remove().

Except for the position in the list of filters, this function behaves exactly
like the append() function.
For more details about its behavior, see also the append() function.

fun()

The fun(string $filter, mixed $parameters = null): callable function can be used to
create a filter function which uses the given built-in $filter.

PHP comes with a useful set of built-in filters.
Using fun() makes accessing these as easy as passing an input string to filter
and getting the filtered output string.

$fun = Clue\StreamFilter\fun('string.rot13');

assert('grfg' === $fun('test'));
assert('test' === $fun($fun('test'));

Please note that not all filter functions may be available depending
on installed PHP extensions and the PHP version in use.
In particular, HHVM may not offer the same filter functions
or parameters as Zend PHP.
Accessing an unknown filter function will result in a RuntimeException:

Clue\StreamFilter\fun('unknown'); // throws RuntimeException

Some filters may accept or require additional filter parameters – most
filters do not require filter parameters.
If given, the optional $parameters argument will be passed to the
underlying filter handler as-is.
In particular, note how not passing this parameter at all differs from
explicitly passing a null value (which many filters do not accept).
Please refer to the individual filter definition for more details.
For example, the string.strip_tags filter can be invoked like this:

$fun = Clue\StreamFilter\fun('string.strip_tags', '<a><b>');

$ret = $fun('<b>h<br>i</b>');
assert('<b>hi</b>' === $ret);

Under the hood, this function allocates a temporary memory stream, so it’s
recommended to clean up the filter function after use.
Also, some filter functions (in particular the
zlib compression filters)
may use internal buffers and may emit a final data chunk on close.
The filter function can be closed by invoking without any arguments:

$fun = Clue\StreamFilter\fun('zlib.deflate');

$ret = $fun('hello') . $fun('world') . $fun();
assert('helloworld' === gzinflate($ret));

The filter function must not be used anymore after it has been closed.
Doing so will result in a RuntimeException:

$fun = Clue\StreamFilter\fun('string.rot13');
$fun();

$fun('test'); // throws RuntimeException

Note: If you’re using the zlib compression filters, then you should be wary
about engine inconsistencies between different PHP versions and HHVM.
These inconsistencies exist in the underlying PHP engines and there’s little we
can do about this in this library.
Our test suite contains several test cases that exhibit these issues.
If you feel some test case is missing or outdated, we’re happy to accept PRs! 😃

remove()

The remove(resource<stream filter> $filter): bool function can be used to
remove a filter previously added via append() or prepend().

$filter = Clue\StreamFilter\append($stream, function () {
    // …
});
Clue\StreamFilter\remove($filter);

Install

The recommended way to install this library is through Composer.
New to Composer?

This project follows SemVer.
This will install the latest supported version:

$ composer require clue/stream-filter:^1.7

See also the CHANGELOG for details about version upgrades.

This project aims to run on any platform and thus does not require any PHP
extensions and supports running on legacy PHP 5.3 through current PHP 8+ and
HHVM.
It’s highly recommended to use the latest supported PHP version for this project.
Older PHP versions may suffer from a number of inconsistencies documented above.

Tests

To run the test suite, you first need to clone this repo and then install all
dependencies through Composer:

$ composer install

To run the test suite, go to the project root and run:

$ vendor/bin/phpunit

License

This project is released under the permissive MIT license.

Did you know that I offer custom development services and issuing invoices for
sponsorships of releases and for contributions? Contact me (@clue) for details.