hypertube-binaries 3.0.2 → 3.0.3

package/Binaries/Php/hypertube/core/handler/HeartBeatHandler.php

@@ -1,20 +1,20 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use Exception;
-use utils\CommandInterface;
-
-final class HeartBeatHandler extends AbstractHandler
-{
-    /**
-     * @throws Exception
-     */
-    public function process(CommandInterface $command)
-    {
-        throw new Exception(__CLASS__ . ' is not implemented in PHP');
-    }
-}
-
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use utils\CommandInterface;
+
+final class HeartBeatHandler extends AbstractHandler
+{
+    /**
+     * @throws Exception
+     */
+    public function process(CommandInterface $command)
+    {
+        throw new Exception(__CLASS__ . ' is not implemented in PHP');
+    }
+}
+

package/Binaries/Php/hypertube/core/handler/InvokeDelegateHandler.php

@@ -1,27 +1,27 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use core\delegatecache\DelegatesCache;
-use utils\CommandInterface;
-
-final class InvokeDelegateHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 1;
-
-    /**
-     * @return mixed
-     */
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $guid = (string) $command->getPayload()[0];
-        $delegate = DelegatesCache::getInstance()->getDelegate($guid);
-        $parameters = array_slice($command->getPayload(), 1);
-
-        return $delegate->invokeArgs(null, $parameters);
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\delegatecache\DelegatesCache;
+use utils\CommandInterface;
+
+final class InvokeDelegateHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $guid = (string) $command->getPayload()[0];
+        $delegate = DelegatesCache::getInstance()->getDelegate($guid);
+        $parameters = array_slice($command->getPayload(), 1);
+
+        return $delegate->invokeArgs(null, $parameters);
+    }
+}

package/Binaries/Php/hypertube/core/handler/InvokeGenericMethodHandler.php

@@ -1,47 +1,47 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use utils\CommandInterface;
-use ReflectionClass;
-use ReflectionException;
-
-final class InvokeGenericMethodHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 2;
-
-    /**
-     * @return mixed
-     */
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $objectOrClass = $command->getPayload()[0];
-        $methodToInvoke = $command->getPayload()[1];
-        $arguments = array_slice($command->getPayload(), 2);
-
-        try {
-            $reflectionClass = new ReflectionClass($objectOrClass);
-            $method = $reflectionClass->getMethod($methodToInvoke);
-
-            return $method->invokeArgs(is_object($objectOrClass) ? $objectOrClass : null, $arguments);
-        } catch (ReflectionException $e) {
-            $reflectionClass = new ReflectionClass($objectOrClass);
-            $methods = $reflectionClass->getMethods();
-            $className = is_object($objectOrClass) ? get_class($objectOrClass) : (string) $objectOrClass;
-            $message = sprintf('Method %s not found in class %s. Available methods:' . PHP_EOL, (string) $methodToInvoke, $className);
-            foreach ($methods as $method) {
-                $params = [];
-                foreach ($method->getParameters() as $param) {
-                    $paramType = $param->getType();
-                    $params[] = ($paramType ? $paramType . ' ' : '') . '$' . $param->getName();
-                }
-                $message .= $method->getName() . '(' . implode(', ', $params) . ')' . PHP_EOL;
-            }
-            throw new ReflectionException($message);
-        }
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+use ReflectionClass;
+use ReflectionException;
+
+final class InvokeGenericMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $objectOrClass = $command->getPayload()[0];
+        $methodToInvoke = $command->getPayload()[1];
+        $arguments = array_slice($command->getPayload(), 2);
+
+        try {
+            $reflectionClass = new ReflectionClass($objectOrClass);
+            $method = $reflectionClass->getMethod($methodToInvoke);
+
+            return $method->invokeArgs(is_object($objectOrClass) ? $objectOrClass : null, $arguments);
+        } catch (ReflectionException $e) {
+            $reflectionClass = new ReflectionClass($objectOrClass);
+            $methods = $reflectionClass->getMethods();
+            $className = is_object($objectOrClass) ? get_class($objectOrClass) : (string) $objectOrClass;
+            $message = sprintf('Method %s not found in class %s. Available methods:' . PHP_EOL, (string) $methodToInvoke, $className);
+            foreach ($methods as $method) {
+                $params = [];
+                foreach ($method->getParameters() as $param) {
+                    $paramType = $param->getType();
+                    $params[] = ($paramType ? $paramType . ' ' : '') . '$' . $param->getName();
+                }
+                $message .= $method->getName() . '(' . implode(', ', $params) . ')' . PHP_EOL;
+            }
+            throw new ReflectionException($message);
+        }
+    }
+}

package/Binaries/Php/hypertube/core/handler/InvokeGenericStaticMethodHandler.php

@@ -1,111 +1,111 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use ReflectionClass;
-use ReflectionMethod;
-use ReflectionException;
-use ReflectionType;
-use utils\CommandInterface;
-
-final class InvokeGenericStaticMethodHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 2;
-
-    /**
-     * @return mixed
-     */
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $payload = $command->getPayload();
-        $className = $payload[0];
-        $methodToInvoke = (string) $payload[1];
-        $arguments = array_slice($payload, 2);
-
-        try {
-            [$reflectionClass, $className] = $this->getReflectionClassAndName($className);
-            if (!$reflectionClass->hasMethod($methodToInvoke)) {
-                $this->throwMethodNotFoundError($reflectionClass, $methodToInvoke, $arguments);
-            }
-
-            $method = $reflectionClass->getMethod($methodToInvoke);
-            if (!$method->isStatic()) {
-                throw new ReflectionException(sprintf(
-                    'Method %s in class %s is not static',
-                        $methodToInvoke,
-                        $className
-                    )
-                );
-            }
-
-            return $method->invokeArgs(null, $arguments);
-
-        } catch (ReflectionException $e) {
-            if (strpos($e->getMessage(), 'Class') === 0) {
-                throw new ReflectionException(sprintf('Class: %s not found', $this->getReflectionClassName($className)));
-            }
-            throw $e;
-        }
-    }
-
-    private function throwMethodNotFoundError(
-        ReflectionClass $reflectionClass,
-        string $methodToInvoke,
-        array $arguments
-    ): void {
-        $className = $reflectionClass->getName();
-        $argumentTypes = array_map('gettype', $arguments);
-
-        $message = sprintf('Generic static method %s with arguments ['
-                   . implode(', ', $argumentTypes)
-                   . '] not found in class %s. Available methods:' . PHP_EOL, $methodToInvoke, $className);
-
-        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC | ReflectionMethod::IS_PUBLIC);
-
-        foreach ($methods as $method) {
-            $parameterTypes = array_map(function($param) {
-                return $this->getParamTypeName($param->getType());
-            }, $method->getParameters());
-            $message .= $method->getName() . ' with arguments ['. implode(', ', $parameterTypes) . "]\n";
-        }
-
-        throw new ReflectionException($message);
-    }
-
-    /**
-     * @param mixed $payload
-     */
-    private function getReflectionClassAndName($classToLoad): array
-    {
-        if ($classToLoad instanceof ReflectionClass) {
-            return [$classToLoad, $classToLoad->getName()];
-        }
-
-        return [new ReflectionClass($classToLoad), (string) $classToLoad];
-    }
-
-    /**
-     * @param mixed $payload
-     */
-    private function getReflectionClassName($classToLoad): string
-    {
-        if ($classToLoad instanceof ReflectionClass) {
-            return $classToLoad->getName();
-        }
-
-        return (string) $classToLoad;
-    }
-
-    private function getParamTypeName(?ReflectionType $paramType): string
-    {
-        if ($paramType) {
-            return $paramType->getName();
-        }
-
-        return 'mixed';
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionException;
+use ReflectionType;
+use utils\CommandInterface;
+
+final class InvokeGenericStaticMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $payload = $command->getPayload();
+        $className = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $arguments = array_slice($payload, 2);
+
+        try {
+            [$reflectionClass, $className] = $this->getReflectionClassAndName($className);
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundError($reflectionClass, $methodToInvoke, $arguments);
+            }
+
+            $method = $reflectionClass->getMethod($methodToInvoke);
+            if (!$method->isStatic()) {
+                throw new ReflectionException(sprintf(
+                    'Method %s in class %s is not static',
+                        $methodToInvoke,
+                        $className
+                    )
+                );
+            }
+
+            return $method->invokeArgs(null, $arguments);
+
+        } catch (ReflectionException $e) {
+            if (strpos($e->getMessage(), 'Class') === 0) {
+                throw new ReflectionException(sprintf('Class: %s not found', $this->getReflectionClassName($className)));
+            }
+            throw $e;
+        }
+    }
+
+    private function throwMethodNotFoundError(
+        ReflectionClass $reflectionClass,
+        string $methodToInvoke,
+        array $arguments
+    ): void {
+        $className = $reflectionClass->getName();
+        $argumentTypes = array_map('gettype', $arguments);
+
+        $message = sprintf('Generic static method %s with arguments ['
+                   . implode(', ', $argumentTypes)
+                   . '] not found in class %s. Available methods:' . PHP_EOL, $methodToInvoke, $className);
+
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC | ReflectionMethod::IS_PUBLIC);
+
+        foreach ($methods as $method) {
+            $parameterTypes = array_map(function($param) {
+                return $this->getParamTypeName($param->getType());
+            }, $method->getParameters());
+            $message .= $method->getName() . ' with arguments ['. implode(', ', $parameterTypes) . "]\n";
+        }
+
+        throw new ReflectionException($message);
+    }
+
+    /**
+     * @param mixed $payload
+     */
+    private function getReflectionClassAndName($classToLoad): array
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return [$classToLoad, $classToLoad->getName()];
+        }
+
+        return [new ReflectionClass($classToLoad), (string) $classToLoad];
+    }
+
+    /**
+     * @param mixed $payload
+     */
+    private function getReflectionClassName($classToLoad): string
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad->getName();
+        }
+
+        return (string) $classToLoad;
+    }
+
+    private function getParamTypeName(?ReflectionType $paramType): string
+    {
+        if ($paramType) {
+            return $paramType->getName();
+        }
+
+        return 'mixed';
+    }
+}

package/Binaries/Php/hypertube/core/handler/InvokeGlobalFunctionHandler.php

@@ -1,48 +1,48 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use Exception;
-use utils\CommandInterface;
-
-final class InvokeGlobalFunctionHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 1;
-
-    /**
-     * @return mixed
-     */
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $functionName = $command->getPayload()[0];
-        $args = array_slice($command->getPayload(), 1);
-
-        if (function_exists($functionName)) {
-            return call_user_func_array($functionName, $args);
-        }
-
-        if (strpos($functionName, '\\') !== false) {
-            if (function_exists($functionName)) {
-                return call_user_func_array($functionName, $args);
-            }
-        }
-
-        if (strpos($functionName, '::') !== false) {
-            [$className, $methodName] = explode('::', $functionName, 2);
-            if (class_exists($className) && method_exists($className, $methodName)) {
-                return call_user_func_array([$className, $methodName], $args);
-            }
-        }
-
-        $availableFunctions = get_defined_functions()['internal'];
-        throw new Exception(sprintf(
-            'Function %s not found. Available built-in internal functions: %s',
-            $functionName,
-            implode(', ', array_slice($availableFunctions, 0, 100)) . '...'
-        ));
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use utils\CommandInterface;
+
+final class InvokeGlobalFunctionHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $functionName = $command->getPayload()[0];
+        $args = array_slice($command->getPayload(), 1);
+
+        if (function_exists($functionName)) {
+            return call_user_func_array($functionName, $args);
+        }
+
+        if (strpos($functionName, '\\') !== false) {
+            if (function_exists($functionName)) {
+                return call_user_func_array($functionName, $args);
+            }
+        }
+
+        if (strpos($functionName, '::') !== false) {
+            [$className, $methodName] = explode('::', $functionName, 2);
+            if (class_exists($className) && method_exists($className, $methodName)) {
+                return call_user_func_array([$className, $methodName], $args);
+            }
+        }
+
+        $availableFunctions = get_defined_functions()['internal'];
+        throw new Exception(sprintf(
+            'Function %s not found. Available built-in internal functions: %s',
+            $functionName,
+            implode(', ', array_slice($availableFunctions, 0, 100)) . '...'
+        ));
+    }
+}

package/Binaries/Php/hypertube/core/handler/InvokeInstanceMethodHandler.php

@@ -1,78 +1,78 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use BadMethodCallException;
-use ReflectionClass;
-use ReflectionMethod;
-use ReflectionException;
-use RuntimeException;
-use utils\ArrayWrapper;
-use utils\CommandInterface;
-
-final class InvokeInstanceMethodHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 2;
-
-    /**
-     * @return mixed
-     */
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $payload = $command->getPayload();
-        $objectInstance = $payload[0];
-        $methodToInvoke = (string) $payload[1];
-        $arguments = array_slice($payload, 2);
-
-        foreach ($arguments as $i => $arg) {
-            if ($arg instanceof ArrayWrapper) {
-                $arguments[$i] = $arg->getData();
-            }
-        }
-
-        try {
-            $reflectionClass = new ReflectionClass($objectInstance);
-
-            if (!$reflectionClass->hasMethod($methodToInvoke)) {
-                $this->throwMethodNotFoundException($objectInstance, $methodToInvoke, $arguments, $reflectionClass);
-            }
-
-            $method = $reflectionClass->getMethod($methodToInvoke);
-            if ($method->isStatic()) {
-                throw new BadMethodCallException(sprintf('Method %s is static and cannot be called on instance', $methodToInvoke));
-            }
-
-            return $method->invokeArgs($objectInstance, $arguments);
-        } catch (ReflectionException $e) {
-            throw new RuntimeException(sprintf('Cannot access the object: %s, error: %s', get_class($objectInstance), $e->getMessage()));
-        }
-    }
-
-    private function throwMethodNotFoundException($objectInstance, string $methodName, array $arguments, ReflectionClass $reflectionClass): void
-    {
-        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC & ~ReflectionMethod::IS_STATIC);
-        $message = sprintf('Instance method %s with arguments %s was not found in class %s.
-            Available instance methods:' . PHP_EOL, $methodName, json_encode($arguments), get_class($objectInstance)
-        );
-
-        foreach ($methods as $method) {
-            $params = [];
-            foreach ($method->getParameters() as $param) {
-                $paramStr = $param->getType() ? $param->getType()->getName() : 'mixed';
-                $paramStr .= ' $' . $param->getName();
-                if ($param->isOptional()) {
-                    $paramStr .= ' = ' . ($param->isDefaultValueAvailable() ?
-                        var_export($param->getDefaultValue(), true) : 'null');
-                }
-                $params[] = $paramStr;
-            }
-            $message .= $method->getName() . '(' . implode(', ', $params) . ")\n";
-        }
-
-        throw new BadMethodCallException($message);
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use BadMethodCallException;
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionException;
+use RuntimeException;
+use utils\ArrayWrapper;
+use utils\CommandInterface;
+
+final class InvokeInstanceMethodHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $payload = $command->getPayload();
+        $objectInstance = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $arguments = array_slice($payload, 2);
+
+        foreach ($arguments as $i => $arg) {
+            if ($arg instanceof ArrayWrapper) {
+                $arguments[$i] = $arg->getData();
+            }
+        }
+
+        try {
+            $reflectionClass = new ReflectionClass($objectInstance);
+
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundException($objectInstance, $methodToInvoke, $arguments, $reflectionClass);
+            }
+
+            $method = $reflectionClass->getMethod($methodToInvoke);
+            if ($method->isStatic()) {
+                throw new BadMethodCallException(sprintf('Method %s is static and cannot be called on instance', $methodToInvoke));
+            }
+
+            return $method->invokeArgs($objectInstance, $arguments);
+        } catch (ReflectionException $e) {
+            throw new RuntimeException(sprintf('Cannot access the object: %s, error: %s', get_class($objectInstance), $e->getMessage()));
+        }
+    }
+
+    private function throwMethodNotFoundException($objectInstance, string $methodName, array $arguments, ReflectionClass $reflectionClass): void
+    {
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC & ~ReflectionMethod::IS_STATIC);
+        $message = sprintf('Instance method %s with arguments %s was not found in class %s.
+            Available instance methods:' . PHP_EOL, $methodName, json_encode($arguments), get_class($objectInstance)
+        );
+
+        foreach ($methods as $method) {
+            $params = [];
+            foreach ($method->getParameters() as $param) {
+                $paramStr = $param->getType() ? $param->getType()->getName() : 'mixed';
+                $paramStr .= ' $' . $param->getName();
+                if ($param->isOptional()) {
+                    $paramStr .= ' = ' . ($param->isDefaultValueAvailable() ?
+                        var_export($param->getDefaultValue(), true) : 'null');
+                }
+                $params[] = $paramStr;
+            }
+            $message .= $method->getName() . '(' . implode(', ', $params) . ")\n";
+        }
+
+        throw new BadMethodCallException($message);
+    }
+}