Initial commit

Author: mbonneau

.gitignore

@@ -0,0 +1,2 @@
+/vendor
+composer.lock

composer.json

@@ -0,0 +1,29 @@
+{
+    "name": "voryx/pool-poretni-cnysa-tcaer",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Matt Bonneau",
+            "email": "[email protected]"
+        },
+        {
+            "name": "David Dan",
+            "email": "[email protected]"
+        }
+    ],
+    "require": {
+        "php": "^7.0",
+        "async-interop/event-loop": "^0.3",
+        "react/event-loop": "^0.4.2"
+    },
+    "require-dev": {
+        "amphp/loop": "dev-master",
+        "phpunit/phpunit": "^5.0",
+        "wyrihaximus/react-async-interop-loop": "dev-master"
+    },
+    "autoload": {
+        "psr-4": {
+            "Voryx\\React\\EventLoop\\": "src/"
+        }
+    }
+}

phpunit.xml.dist

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="tests/bootstrap.php" colors="true">
+    <testsuites>
+        <testsuite name="Test Suite">
+            <directory>tests/</directory>
+        </testsuite>
+    </testsuites>
+    <filter>
+        <whitelist>
+            <directory suffix=".php">src/</directory>
+        </whitelist>
+    </filter>
+</phpunit>

src/ReactAsyncInteropLoop.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace Voryx\React\EventLoop;
+
+use Interop\Async\Loop;
+use React\EventLoop\LoopInterface;
+use React\EventLoop\Timer\TimerInterface;
+
+class ReactAsyncInteropLoop implements LoopInterface
+{
+    private $readStreams = [];
+    private $writeStreams = [];
+
+    public function addReadStream($stream, callable $listener)
+    {
+        $key = (int)$stream;
+        if (isset($this->readStreams[$key])) {
+            throw new \Exception('key set twice');
+        }
+        $this->readStreams[$key] = Loop::get()->onReadable($stream, function () use ($listener, $stream) {
+            $listener($stream);
+        });
+    }
+
+    public function addWriteStream($stream, callable $listener)
+    {
+        $key = (int)$stream;
+
+        if (isset($this->writeStreams[$key])) {
+            throw new \Exception('key set twice');
+        }
+
+        $this->writeStreams[$key] = Loop::get()->onWritable($stream, function () use ($listener, $stream) {
+            $listener($stream);
+        });
+    }
+
+    public function removeReadStream($stream)
+    {
+        $key = (int)$stream;
+        if (isset($this->readStreams[$key])) {
+            Loop::get()->cancel($this->readStreams[$key]);
+            unset($this->readStreams[$key]);
+        }
+    }
+
+    public function removeWriteStream($stream)
+    {
+        $key = (int)$stream;
+        if (isset($this->writeStreams[$key])) {
+            Loop::get()->cancel($this->writeStreams[$key]);
+            unset($this->writeStreams[$key]);
+        }
+    }
+
+    public function removeStream($stream)
+    {
+        $this->removeReadStream($stream);
+        $this->removeWriteStream($stream);
+    }
+
+    private function addWrappedTimer($interval, callable $callback, $isPeriodic = false)
+    {
+        $wrappedCallback = function () use (&$timer, $callback) {
+            $callback($timer);
+        };
+        $millis          = $interval * 1000;
+        if ($isPeriodic) {
+            $timerKey = Loop::get()->repeat($millis, $wrappedCallback);
+        } else {
+            $timerKey = Loop::get()->delay($millis, $wrappedCallback);
+        }
+        $timer = new ReactAsyncInteropTimer(
+            $timerKey,
+            $interval,
+            $callback,
+            $this,
+            false
+        );
+        return $timer;
+    }
+
+    public function addTimer($interval, callable $callback)
+    {
+        return $this->addWrappedTimer($interval, $callback);
+    }
+
+    public function addPeriodicTimer($interval, callable $callback)
+    {
+        return $this->addWrappedTimer($interval, $callback, true);
+    }
+
+    public function cancelTimer(TimerInterface $timer)
+    {
+        $timer->cancel();
+    }
+
+    public function isTimerActive(TimerInterface $timer)
+    {
+        return $timer->isActive();
+    }
+
+    public function nextTick(callable $listener)
+    {
+        Loop::get()->defer(function () use ($listener) {
+            $listener($this);
+        });
+    }
+
+    public function futureTick(callable $listener)
+    {
+        $this->nextTick($listener);
+    }
+
+    public function tick()
+    {
+        $loop = Loop::get();
+
+        $loop->defer(function () use ($loop) {
+            $loop->stop();
+        });
+
+        $loop->run();
+    }
+
+    public function run()
+    {
+        Loop::get()->run();
+    }
+
+    public function stop()
+    {
+        Loop::get()->stop();
+    }
+}

src/ReactAsyncInteropTimer.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Voryx\React\EventLoop;
+
+use Interop\Async\Loop;
+use React\EventLoop\LoopInterface;
+use React\EventLoop\Timer\Timer;
+
+class ReactAsyncInteropTimer extends Timer
+{
+    private $timerKey;
+
+    public function __construct($timerKey, $interval, callable $callback, LoopInterface $loop, $isPeriodic = false, $data = null)
+    {
+        $this->timerKey = $timerKey;
+
+        parent::__construct($loop, $interval, $callback, $isPeriodic, $data);
+    }
+
+    public function cancel()
+    {
+        Loop::get()->cancel($this->timerKey);
+    }
+}

tests/ReactAsyncInteropLoopTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Voryx\Tests\React\EventLoop;
+
+use Interop\Async\Loop;
+use React\EventLoop\StreamSelectLoop;
+use React\Tests\EventLoop\AbstractLoopTest;
+use Voryx\React\EventLoop\ReactAsyncInteropLoop;
+use WyriHaximus\React\AsyncInteropLoop\ReactDriverFactory;
+
+class ReactAsyncInteropLoopTest extends AbstractLoopTest
+{
+    public function createLoop()
+    {
+        // going to use the react loop adapter as the default for now
+        $driver = ReactDriverFactory::createFactoryFromLoop(StreamSelectLoop::class);
+        Loop::setFactory($driver);
+
+        return new ReactAsyncInteropLoop();
+    }
+
+    public function testRecursiveNextTick()
+    {
+        $this->markTestSkipped('Recursive next tick behavior does not match right now');
+    }
+}

tests/ReactAsyncInteropLoopWithAmpTest.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Voryx\Tests\React\EventLoop;
+
+use Amp\Loop\LoopFactory;
+use Interop\Async\Loop;
+use React\Tests\EventLoop\AbstractLoopTest;
+use Voryx\React\EventLoop\ReactAsyncInteropLoop;
+
+class ReactAsyncInteropLoopWithAmpTest extends AbstractLoopTest
+{
+    public function createLoop()
+    {
+        Loop::setFactory(new LoopFactory());
+        return new ReactAsyncInteropLoop();
+    }
+
+    public function testRecursiveNextTick()
+    {
+        $this->markTestSkipped('Recursive next tick behavior does not match right now');
+    }
+}

tests/bootstrap.php

@@ -0,0 +1,4 @@
+<?php
+
+$loader = @include __DIR__ . '/../vendor/autoload.php';
+$loader->addPsr4('React\\Tests\\EventLoop\\', __DIR__ . '/../vendor/react/event-loop/tests/');