Actualización

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/AbstractBaseFactory.php

@@ -0,0 +1,129 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use ProxyManager\Configuration;
+use ProxyManager\Generator\ClassGenerator;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+use ProxyManager\Version;
+use ReflectionClass;
+
+/**
+ * Base factory common logic
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @license MIT
+ */
+abstract class AbstractBaseFactory
+{
+    /**
+     * @var \ProxyManager\Configuration
+     */
+    protected $configuration;
+
+    /**
+     * Cached checked class names
+     *
+     * @var string[]
+     */
+    private $checkedClasses = [];
+
+    /**
+     * @param \ProxyManager\Configuration $configuration
+     */
+    public function __construct(Configuration $configuration = null)
+    {
+        $this->configuration = $configuration ?: new Configuration();
+    }
+
+    /**
+     * Generate a proxy from a class name
+     *
+     * @param string  $className
+     * @param mixed[] $proxyOptions
+     *
+     * @return string proxy class name
+     */
+    protected function generateProxy(string $className, array $proxyOptions = []) : string
+    {
+        if (isset($this->checkedClasses[$className])) {
+            return $this->checkedClasses[$className];
+        }
+
+        $proxyParameters = [
+            'className'           => $className,
+            'factory'             => get_class($this),
+            'proxyManagerVersion' => Version::getVersion(),
+        ];
+        $proxyClassName  = $this
+            ->configuration
+            ->getClassNameInflector()
+            ->getProxyClassName($className, $proxyParameters);
+
+        if (! class_exists($proxyClassName)) {
+            $this->generateProxyClass(
+                $proxyClassName,
+                $className,
+                $proxyParameters,
+                $proxyOptions
+            );
+        }
+
+        $this
+            ->configuration
+            ->getSignatureChecker()
+            ->checkSignature(new ReflectionClass($proxyClassName), $proxyParameters);
+
+        return $this->checkedClasses[$className] = $proxyClassName;
+    }
+
+    abstract protected function getGenerator() : ProxyGeneratorInterface;
+
+    /**
+     * Generates the provided `$proxyClassName` from the given `$className` and `$proxyParameters`
+     *
+     * @param string  $proxyClassName
+     * @param string  $className
+     * @param array   $proxyParameters
+     * @param mixed[] $proxyOptions
+     *
+     * @return void
+     */
+    private function generateProxyClass(
+        string $proxyClassName,
+        string $className,
+        array $proxyParameters,
+        array $proxyOptions = []
+    ) {
+        $className = $this->configuration->getClassNameInflector()->getUserClassName($className);
+        $phpClass  = new ClassGenerator($proxyClassName);
+
+        $this->getGenerator()->generate(new ReflectionClass($className), $phpClass, $proxyOptions);
+
+        $phpClass = $this->configuration->getClassSignatureGenerator()->addSignature($phpClass, $proxyParameters);
+
+        $this->configuration->getGeneratorStrategy()->generate($phpClass, $proxyOptions);
+
+        $autoloader = $this->configuration->getProxyAutoloader();
+
+        $autoloader($proxyClassName);
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/AccessInterceptorScopeLocalizerFactory.php

@@ -0,0 +1,66 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use ProxyManager\Proxy\AccessInterceptorInterface;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizerGenerator;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+
+/**
+ * Factory responsible of producing proxy objects
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @license MIT
+ */
+class AccessInterceptorScopeLocalizerFactory extends AbstractBaseFactory
+{
+    /**
+     * @var \ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizerGenerator|null
+     */
+    private $generator;
+
+    /**
+     * @param object     $instance           the object to be localized within the access interceptor
+     * @param \Closure[] $prefixInterceptors an array (indexed by method name) of interceptor closures to be called
+     *                                       before method logic is executed
+     * @param \Closure[] $suffixInterceptors an array (indexed by method name) of interceptor closures to be called
+     *                                       after method logic is executed
+     *
+     * @return AccessInterceptorInterface
+     */
+    public function createProxy(
+        $instance,
+        array $prefixInterceptors = [],
+        array $suffixInterceptors = []
+    ) : AccessInterceptorInterface {
+        $proxyClassName = $this->generateProxy(get_class($instance));
+
+        return $proxyClassName::staticProxyConstructor($instance, $prefixInterceptors, $suffixInterceptors);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getGenerator() : ProxyGeneratorInterface
+    {
+        return $this->generator ?: $this->generator = new AccessInterceptorScopeLocalizerGenerator();
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/AccessInterceptorValueHolderFactory.php

@@ -0,0 +1,66 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use ProxyManager\Proxy\AccessInterceptorValueHolderInterface;
+use ProxyManager\ProxyGenerator\AccessInterceptorValueHolderGenerator;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+
+/**
+ * Factory responsible of producing proxy objects
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @license MIT
+ */
+class AccessInterceptorValueHolderFactory extends AbstractBaseFactory
+{
+    /**
+     * @var \ProxyManager\ProxyGenerator\AccessInterceptorValueHolderGenerator|null
+     */
+    private $generator;
+
+    /**
+     * @param object     $instance           the object to be wrapped within the value holder
+     * @param \Closure[] $prefixInterceptors an array (indexed by method name) of interceptor closures to be called
+     *                                       before method logic is executed
+     * @param \Closure[] $suffixInterceptors an array (indexed by method name) of interceptor closures to be called
+     *                                       after method logic is executed
+     *
+     * @return AccessInterceptorValueHolderInterface
+     */
+    public function createProxy(
+        $instance,
+        array $prefixInterceptors = [],
+        array $suffixInterceptors = []
+    ) : AccessInterceptorValueHolderInterface {
+        $proxyClassName = $this->generateProxy(get_class($instance));
+
+        return $proxyClassName::staticProxyConstructor($instance, $prefixInterceptors, $suffixInterceptors);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getGenerator() : ProxyGeneratorInterface
+    {
+        return $this->generator ?: $this->generator = new AccessInterceptorValueHolderGenerator();
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/LazyLoadingGhostFactory.php

@@ -0,0 +1,96 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use Closure;
+use ProxyManager\Proxy\GhostObjectInterface;
+use ProxyManager\ProxyGenerator\LazyLoadingGhostGenerator;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+
+/**
+ * Factory responsible of producing ghost instances
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @license MIT
+ */
+class LazyLoadingGhostFactory extends AbstractBaseFactory
+{
+    /**
+     * @var \ProxyManager\ProxyGenerator\LazyLoadingGhostGenerator|null
+     */
+    private $generator;
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getGenerator() : ProxyGeneratorInterface
+    {
+        return $this->generator ?: $this->generator = new LazyLoadingGhostGenerator();
+    }
+
+    /**
+     * Creates a new lazy proxy instance of the given class with
+     * the given initializer
+     *
+     * Please refer to the following documentation when using this method:
+     *
+     * @link https://github.com/Ocramius/ProxyManager/blob/master/docs/lazy-loading-ghost-object.md
+     *
+     * @param string  $className   name of the class to be proxied
+     * @param Closure $initializer initializer to be passed to the proxy. The initializer closure should have following
+     *                             signature:
+     *
+     *                             <code>
+     *                             $initializer = function (
+     *                                 GhostObjectInterface $proxy,
+     *                                 string $method,
+     *                                 array $parameters,
+     *                                 & $initializer,
+     *                                 array $properties
+     *                             ) {};
+     *                             </code>
+     *
+     *                             Where:
+     *                              - $proxy is the proxy instance on which the initializer is acting
+     *                              - $method is the name of the method that triggered the lazy initialization
+     *                              - $parameters are the parameters that were passed to $method
+     *                              - $initializer by-ref initializer - should be assigned null in the initializer body
+     *                              - $properties a by-ref map of the properties of the object, indexed by PHP
+     *                                            internal property name. Assign values to it to initialize the
+     *                                            object state
+     *
+     * @param mixed[] $proxyOptions a set of options to be used when generating the proxy. Currently supports only
+     *                              key "skippedProperties", which allows to skip lazy-loading of some properties.
+     *                              "skippedProperties" is a string[], containing a list of properties referenced
+     *                              via PHP's internal property name (i.e. "\0ClassName\0propertyName")
+     *
+     * @return GhostObjectInterface
+     */
+    public function createProxy(
+        string $className,
+        Closure $initializer,
+        array $proxyOptions = []
+    ) : GhostObjectInterface {
+        $proxyClassName = $this->generateProxy($className, $proxyOptions);
+
+        return $proxyClassName::staticProxyConstructor($initializer);
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/LazyLoadingValueHolderFactory.php

@@ -0,0 +1,57 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use ProxyManager\Proxy\VirtualProxyInterface;
+use ProxyManager\ProxyGenerator\LazyLoadingValueHolderGenerator;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+
+/**
+ * Factory responsible of producing virtual proxy instances
+ *
+ * @author Marco Pivetta <ocramius@gmail.com>
+ * @license MIT
+ */
+class LazyLoadingValueHolderFactory extends AbstractBaseFactory
+{
+    /**
+     * @var \ProxyManager\ProxyGenerator\LazyLoadingValueHolderGenerator|null
+     */
+    private $generator;
+
+    public function createProxy(
+        string $className,
+        \Closure $initializer,
+        array $proxyOptions = []
+    ) : VirtualProxyInterface {
+        $proxyClassName = $this->generateProxy($className, $proxyOptions);
+
+        return $proxyClassName::staticProxyConstructor($initializer);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getGenerator() : ProxyGeneratorInterface
+    {
+        return $this->generator ?: $this->generator = new LazyLoadingValueHolderGenerator();
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/NullObjectFactory.php

@@ -0,0 +1,60 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use ProxyManager\Proxy\NullObjectInterface;
+use ProxyManager\ProxyGenerator\NullObjectGenerator;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+
+/**
+ * Factory responsible of producing proxy objects
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+class NullObjectFactory extends AbstractBaseFactory
+{
+    /**
+     * @var \ProxyManager\ProxyGenerator\NullObjectGenerator|null
+     */
+    private $generator;
+
+    /**
+     * @param object $instanceOrClassName the object to be wrapped or interface to transform to null object
+     *
+     * @return NullObjectInterface
+     */
+    public function createProxy($instanceOrClassName) : NullObjectInterface
+    {
+        $className      = is_object($instanceOrClassName) ? get_class($instanceOrClassName) : $instanceOrClassName;
+        $proxyClassName = $this->generateProxy($className);
+
+        return $proxyClassName::staticProxyConstructor();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getGenerator() : ProxyGeneratorInterface
+    {
+        return $this->generator ?: $this->generator = new NullObjectGenerator();
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/RemoteObject/Adapter/BaseAdapter.php

@@ -0,0 +1,83 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory\RemoteObject\Adapter;
+
+use ProxyManager\Factory\RemoteObject\AdapterInterface;
+use Zend\Server\Client;
+
+/**
+ * Remote Object base adapter
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+abstract class BaseAdapter implements AdapterInterface
+{
+    /**
+     * Adapter client
+     *
+     * @var \Zend\Server\Client
+     */
+    protected $client;
+
+    /**
+     * Service name mapping
+     *
+     * @var string[]
+     */
+    protected $map = [];
+
+    /**
+     * Constructor
+     *
+     * @param Client $client
+     * @param array  $map    map of service names to their aliases
+     */
+    public function __construct(Client $client, array $map = [])
+    {
+        $this->client = $client;
+        $this->map    = $map;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function call(string $wrappedClass, string $method, array $params = [])
+    {
+        $serviceName = $this->getServiceName($wrappedClass, $method);
+
+        if (isset($this->map[$serviceName])) {
+            $serviceName = $this->map[$serviceName];
+        }
+
+        return $this->client->call($serviceName, $params);
+    }
+
+    /**
+     * Get the service name will be used by the adapter
+     *
+     * @param string $wrappedClass
+     * @param string $method
+     *
+     * @return string Service name
+     */
+    abstract protected function getServiceName(string $wrappedClass, string $method) : string;
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/RemoteObject/Adapter/JsonRpc.php

@@ -0,0 +1,38 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory\RemoteObject\Adapter;
+
+/**
+ * Remote Object JSON RPC adapter
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+class JsonRpc extends BaseAdapter
+{
+    /**
+     * {@inheritDoc}
+     */
+    protected function getServiceName(string $wrappedClass, string $method) : string
+    {
+        return $wrappedClass . '.' . $method;
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/RemoteObject/Adapter/Soap.php

@@ -0,0 +1,38 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory\RemoteObject\Adapter;
+
+/**
+ * Remote Object SOAP adapter
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+class Soap extends BaseAdapter
+{
+    /**
+     * {@inheritDoc}
+     */
+    protected function getServiceName(string $wrappedClass, string $method) : string
+    {
+        return $method;
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/RemoteObject/Adapter/XmlRpc.php

@@ -0,0 +1,38 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory\RemoteObject\Adapter;
+
+/**
+ * Remote Object XML RPC adapter
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+class XmlRpc extends BaseAdapter
+{
+    /**
+     * {@inheritDoc}
+     */
+    protected function getServiceName(string $wrappedClass, string $method) : string
+    {
+        return $wrappedClass . '.' . $method;
+    }
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/RemoteObject/AdapterInterface.php

@@ -0,0 +1,39 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory\RemoteObject;
+
+/**
+ * Remote Object adapter interface
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+interface AdapterInterface
+{
+    /**
+     * Call remote object
+     *
+     * @param string $wrappedClass
+     * @param string $method
+     * @param array  $params
+     */
+    public function call(string $wrappedClass, string $method, array $params = []);
+}

vendor/ocramius/proxy-manager/src/ProxyManager/Factory/RemoteObjectFactory.php

@@ -0,0 +1,81 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license.
+ */
+
+declare(strict_types=1);
+
+namespace ProxyManager\Factory;
+
+use ProxyManager\Configuration;
+use ProxyManager\Factory\RemoteObject\AdapterInterface;
+use ProxyManager\Proxy\RemoteObjectInterface;
+use ProxyManager\ProxyGenerator\ProxyGeneratorInterface;
+use ProxyManager\ProxyGenerator\RemoteObjectGenerator;
+
+/**
+ * Factory responsible of producing remote proxy objects
+ *
+ * @author Vincent Blanchon <blanchon.vincent@gmail.com>
+ * @license MIT
+ */
+class RemoteObjectFactory extends AbstractBaseFactory
+{
+    /**
+     * @var AdapterInterface
+     */
+    protected $adapter;
+
+    /**
+     * @var \ProxyManager\ProxyGenerator\RemoteObjectGenerator|null
+     */
+    private $generator;
+
+    /**
+     * {@inheritDoc}
+     *
+     * @param AdapterInterface $adapter
+     * @param Configuration    $configuration
+     */
+    public function __construct(AdapterInterface $adapter, Configuration $configuration = null)
+    {
+        parent::__construct($configuration);
+
+        $this->adapter = $adapter;
+    }
+
+    /**
+     * @param string|object $instanceOrClassName
+     *
+     * @return RemoteObjectInterface
+     */
+    public function createProxy($instanceOrClassName) : RemoteObjectInterface
+    {
+        $proxyClassName = $this->generateProxy(
+            is_object($instanceOrClassName) ? get_class($instanceOrClassName) : $instanceOrClassName
+        );
+
+        return $proxyClassName::staticProxyConstructor($this->adapter);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getGenerator() : ProxyGeneratorInterface
+    {
+        return $this->generator ?: $this->generator = new RemoteObjectGenerator();
+    }
+}