/**
* @param $exitCode
* @param InputInterface $input
* @param OutputInterface $output
*/
public function onPeridotEnd($exitCode, InputInterface $input, OutputInterface $output)
{
$this->emitter->removeListener('peridot.end', [$this, 'onPeridotEnd']);
if (!$input->getOption('watch')) {
return;
}
$watcher = $this->getWatcher();
$watcher->setInput($input);
$watcher->setOutput($output);
$watcher->setCriteria($this->getFileCriteria());
$this->watch($watcher);
}
/**
*
* @param EventEmitterInterface $emitter
* @param string[] $fulfillEvents
* @param string[] $rejectEvents
* @param string[] $notifyEvents
* @return ExtendedPromiseInterface
*/
public static function listen(EventEmitterInterface $emitter, array $fulfillEvents = [], array $rejectEvents = [], array $notifyEvents = [])
{
$listeners = [];
$removeListeners = function () use($emitter, &$listeners) {
foreach ($listeners as $event => $callback) {
$emitter->removeListener($event, $callback);
}
$listeners = [];
};
$promise = new Promise(function ($resolve, $reject, $notify) use($emitter, &$listeners, $fulfillEvents, $rejectEvents, $notifyEvents) {
$listeners = array_merge(static::registerCallbacks($emitter, $fulfillEvents, $resolve), static::registerCallbacks($emitter, $rejectEvents, $reject), static::registerCallbacks($emitter, $notifyEvents, $notify));
}, $removeListeners);
return $promise->always($removeListeners);
}
/**
* Detach the plugin.
*/
public function detach(EventEmitterInterface $emitter)
{
$emitter->removeListener('suite.define', [$this, 'onSuiteDefine']);
$emitter->removeListener('suite.start', [$this, 'onSuiteStart']);
}
/**
* Creates a `Promise` which resolves with an array of all the event data
*
* @param ReadableStreamInterface|WritableStreamInterface $stream
* @param string $event
* @return CancellablePromiseInterface Promise<string, Exception>
*/
function all(EventEmitterInterface $stream, $event = 'data')
{
// stream already ended => resolve with empty buffer
if ($stream instanceof ReadableStreamInterface) {
// readable or duplex stream not readable => already closed
// a half-open duplex stream is considered closed if its readable side is closed
if (!$stream->isReadable()) {
return Promise\resolve(array());
}
} elseif ($stream instanceof WritableStreamInterface) {
// writable-only stream (not duplex) not writable => already closed
if (!$stream->isWritable()) {
return Promise\resolve(array());
}
}
$buffer = array();
$bufferer = function ($data) use(&$buffer) {
$buffer[] = $data;
};
$stream->on($event, $bufferer);
$promise = new Promise\Promise(function ($resolve, $reject) use($stream, &$buffer) {
$stream->on('error', function ($error) use($reject) {
$reject(new \RuntimeException('An error occured on the underlying stream while buffering', 0, $error));
});
$stream->on('close', function () use($resolve, &$buffer) {
$resolve($buffer);
});
}, function ($_, $reject) {
$reject(new \RuntimeException('Cancelled buffering'));
});
return $promise->then(null, function ($error) use(&$buffer, $bufferer, $stream, $event) {
// promise rejected => clear buffer and buffering
$buffer = array();
$stream->removeListener($event, $bufferer);
throw $error;
});
}
/**
* Removes the given listener for the given event.
*
* @param string $event Must be one of state machine's $supported_events, hence one of the ON_* constants.
* @param callable $listener
*/
public function removeListener($event, callable $listener)
{
$this->event_emitter->removeListener($event, $listener);
}
