Merge pull request #3 from reactphp-parallel/code

Add Code

Author: WyriHaximus

src/ContainerProxy.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\Psr11ContainerProxy;
+
+use Psr\Container\ContainerInterface;
+use ReactParallel\ObjectProxy\Proxy;
+
+final class ContainerProxy
+{
+    private ContainerInterface $proxy;
+
+    public function __construct(ContainerInterface $container, Proxy $proxy)
+    {
+        /**
+         * @psalm-suppress PropertyTypeCoercion
+         * @phpstan-ignore-next-line
+         */
+        $this->proxy = $proxy->create($container, ContainerInterface::class);
+    }
+
+    public function create(ContainerInterface $container): ContainerInterface
+    {
+        return new ThreadContainerProxy($container, $this->proxy);
+    }
+}

src/ThreadContainerProxy.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\Psr11ContainerProxy;
+
+use Psr\Container\ContainerInterface;
+use ReactParallel\ObjectProxy\Generated\ProxyList;
+
+use function array_key_exists;
+
+final class ThreadContainerProxy extends ProxyList implements ContainerInterface
+{
+    private ContainerInterface $local;
+    private ContainerInterface $remote;
+
+    public function __construct(ContainerInterface $local, ContainerInterface $remote)
+    {
+        $this->local  = $local;
+        $this->remote = $remote;
+    }
+
+    // phpcs:disable
+    public function has($id)
+    {
+        return array_key_exists($id, self::KNOWN_INTERFACE) || $this->local->has($id);
+    }
+
+    // phpcs:disable
+    public function get($id)
+    {
+        if (array_key_exists($id, self::KNOWN_INTERFACE)) {
+            return $this->remote->get($id);
+        }
+
+        return $this->local->get($id);
+    }
+}

tests/ContainerProxyTest.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\Tests\Psr11ContainerProxy;
+
+use React\EventLoop\Factory as EventLoopFactory;
+use ReactParallel\Factory;
+use ReactParallel\ObjectProxy\Proxy;
+use ReactParallel\Psr11ContainerProxy\ContainerProxy;
+use ReactParallel\Psr11ContainerProxy\ThreadContainerProxy;
+use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
+use Yuloh\Container\Container;
+
+final class ContainerProxyTest extends AsyncTestCase
+{
+    /**
+     * @test
+     */
+    public function create(): void
+    {
+        $loop           = EventLoopFactory::create();
+        $factory        = new Factory($loop);
+        $proxy          = new Proxy($factory);
+        $containerProxy = new ContainerProxy(new Container(), $proxy);
+
+        self::assertInstanceOf(ThreadContainerProxy::class, $containerProxy->create(new Container()));
+    }
+}

tests/ThreadContainerProxyTest.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\Tests\Psr11ContainerProxy;
+
+use Monolog\Logger;
+use Psr\Container\ContainerInterface;
+use Psr\Log\LoggerInterface;
+use ReactParallel\Psr11ContainerProxy\ThreadContainerProxy;
+use stdClass;
+use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
+
+final class ThreadContainerProxyTest extends AsyncTestCase
+{
+    /**
+     * @test
+     */
+    public function logger(): void
+    {
+        $std    = new stdClass();
+        $logger = new Logger('monolog');
+        $local  = $this->prophesize(ContainerInterface::class);
+        $local->has('fake')->shouldBeCalled()->willReturn(true);
+        $local->get('fake')->shouldBeCalled()->willReturn($std);
+        $local->has(LoggerInterface::class)->shouldNotBeCalled();
+        $local->get(LoggerInterface::class)->shouldNotBeCalled();
+        $remote = $this->prophesize(ContainerInterface::class);
+        $remote->has('fake')->shouldNotBeCalled();
+        $remote->get('fake')->shouldNotBeCalled();
+        $remote->get(LoggerInterface::class)->shouldBeCalled()->willReturn($logger);
+
+        $proxy = new ThreadContainerProxy($local->reveal(), $remote->reveal());
+
+        self::assertTrue($proxy->has('fake'));
+        self::assertTrue($proxy->has(LoggerInterface::class));
+        self::assertSame($std, $proxy->get('fake'));
+        self::assertSame($logger, $proxy->get(LoggerInterface::class));
+    }
+}