hypertube-binaries 3.0.2 → 3.0.4

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

@@ -1,109 +1,109 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use ReflectionClass;
-use ReflectionException;
-use ReflectionMethod;
-use ReflectionType;
-use utils\CommandInterface;
-
-final class GetStaticMethodAsDelegateHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 2;
-
-    public function process(CommandInterface $command): ReflectionMethod
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $payload = $command->getPayload();
-        $classToLoad = $payload[0];
-        $methodToInvoke = (string) $payload[1];
-        $argumentsTypes = array_slice($payload, 2);
-
-        try {
-            $reflectionClass = $this->getReflectionClass($classToLoad);
-            if (!$reflectionClass->hasMethod($methodToInvoke)) {
-                $this->throwMethodNotFoundException($reflectionClass, $methodToInvoke, $argumentsTypes);
-            }
-
-            $foundMethod = $reflectionClass->getMethod($methodToInvoke);
-            if (!$foundMethod->isStatic()) {
-                throw new ReflectionException(sprintf('Method %s is not a static method in the class.', $reflectionClass->getName()));
-            }
-
-            return $foundMethod;
-
-        } catch (ReflectionException $e) {
-
-            if (strpos($e->getMessage(), 'does not exist') !== false) {
-                throw new ReflectionException(sprintf(
-                    'Class: %s does not exist',
-                    $this->getReflectionClassName($classToLoad)
-                ));
-            }
-            throw $e;
-        }
-    }
-
-    private function throwMethodNotFoundException(
-        ReflectionClass $reflectionClass,
-        string $methodName,
-        array $argumentsTypes
-    ): void {
-        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC);
-        $argumentsTypesStr = implode(', ', array_map('gettype', $argumentsTypes));
-
-        $message = sprintf(
-            'Static method %s with arguments [%s] was not found in class %s}. Available static methods:' . PHP_EOL,
-            $methodName,
-            $argumentsTypesStr,
-            $reflectionClass->getName()
-        );
-        foreach ($methods as $method) {
-            $paramTypes = array_map(function($param) {
-                return $this->getParamTypeName($param->getType());
-            }, $method->getParameters());
-
-            $paramTypesStr = implode(', ', $paramTypes);
-            $message .= $method->getName() . 'with arguments [ ' . $paramTypesStr . ']' . PHP_EOL;
-        }
-
-        throw new ReflectionException($message);
-    }
-
-    /**
-     * @param mixed $classToLoad
-     */
-    private function getReflectionClass($classToLoad): ReflectionClass
-    {
-        if ($classToLoad instanceof ReflectionClass) {
-            return $classToLoad;
-        }
-
-        return new ReflectionClass($classToLoad);
-    }
-
-    /**
-     * @param mixed $classToLoad
-     */
-    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 ReflectionException;
+use ReflectionMethod;
+use ReflectionType;
+use utils\CommandInterface;
+
+final class GetStaticMethodAsDelegateHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    public function process(CommandInterface $command): ReflectionMethod
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $payload = $command->getPayload();
+        $classToLoad = $payload[0];
+        $methodToInvoke = (string) $payload[1];
+        $argumentsTypes = array_slice($payload, 2);
+
+        try {
+            $reflectionClass = $this->getReflectionClass($classToLoad);
+            if (!$reflectionClass->hasMethod($methodToInvoke)) {
+                $this->throwMethodNotFoundException($reflectionClass, $methodToInvoke, $argumentsTypes);
+            }
+
+            $foundMethod = $reflectionClass->getMethod($methodToInvoke);
+            if (!$foundMethod->isStatic()) {
+                throw new ReflectionException(sprintf('Method %s is not a static method in the class.', $reflectionClass->getName()));
+            }
+
+            return $foundMethod;
+
+        } catch (ReflectionException $e) {
+
+            if (strpos($e->getMessage(), 'does not exist') !== false) {
+                throw new ReflectionException(sprintf(
+                    'Class: %s does not exist',
+                    $this->getReflectionClassName($classToLoad)
+                ));
+            }
+            throw $e;
+        }
+    }
+
+    private function throwMethodNotFoundException(
+        ReflectionClass $reflectionClass,
+        string $methodName,
+        array $argumentsTypes
+    ): void {
+        $methods = $reflectionClass->getMethods(ReflectionMethod::IS_STATIC);
+        $argumentsTypesStr = implode(', ', array_map('gettype', $argumentsTypes));
+
+        $message = sprintf(
+            'Static method %s with arguments [%s] was not found in class %s}. Available static methods:' . PHP_EOL,
+            $methodName,
+            $argumentsTypesStr,
+            $reflectionClass->getName()
+        );
+        foreach ($methods as $method) {
+            $paramTypes = array_map(function($param) {
+                return $this->getParamTypeName($param->getType());
+            }, $method->getParameters());
+
+            $paramTypesStr = implode(', ', $paramTypes);
+            $message .= $method->getName() . 'with arguments [ ' . $paramTypesStr . ']' . PHP_EOL;
+        }
+
+        throw new ReflectionException($message);
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($classToLoad);
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    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/GetTypeHandler.php

@@ -1,146 +1,146 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use core\handler\loadLibrary\ClasspathScanner;
-use core\namespacescache\NamespacesCache;
-use core\typescache\TypesCache;
-use Exception;
-use ReflectionClass;
-use utils\CommandInterface;
-
-final class GetTypeHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 1;
-    private array $primitiveTypeMap;
-
-    public function __construct()
-    {
-        $this->primitiveTypeMap = [
-            'boolean' => 'bool',
-            'bool' => 'bool',
-            'integer' => 'int',
-            'int' => 'int',
-            'double' => 'float',
-            'float' => 'float',
-            'string' => 'string',
-            'array' => 'array',
-            'object' => 'object',
-            'resource' => 'resource',
-            'null' => 'null'
-        ];
-    }
-
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $typeName = $this->getTypeName($command);
-
-        if (array_key_exists($typeName, $this->primitiveTypeMap)) {
-            $typeToReturn = $this->primitiveTypeMap[$typeName];
-        } else {
-            try {
-                if (class_exists($typeName)) {
-                    $typeToReturn = new ReflectionClass($typeName);
-                } else {
-                    if (class_exists($typeName)) {
-                        $typeToReturn = new ReflectionClass($typeName);
-                    } else {
-                        throw new Exception('Class not found: ' . $typeName);
-                    }
-                }
-            } catch (Exception $ex) {
-                $loadedLibraries = LoadLibraryHandler::getLoadedLibraries();
-                $loadedClasses = [];
-
-                foreach ($loadedLibraries as $library) {
-                    if (substr($library, -4) === '.php' || substr($library, -5) === '.phar') {
-                        $scanner = new ClasspathScanner();
-                        $loadedClasses = array_merge(
-                            $loadedClasses,
-                            $scanner->getClassesFromFile($library)
-                        );
-                    }
-                }
-
-                $availableClasses = implode(PHP_EOL, $loadedClasses) .
-                    implode(PHP_EOL, get_declared_classes());
-
-                $includePath = get_include_path();
-
-                throw new Exception(sprintf(
-                    'Type: %s not found in include path' . PHP_EOL
-                    . 'Load all libraries at the beginning of your application' . PHP_EOL
-                    . 'Exception: %s' . PHP_EOL
-                    . 'PHP include path: %s' . PHP_EOL
-                    . 'Available classes loaded by user: %s' . PHP_EOL,
-                    $typeName,
-                    $ex->getMessage(),
-                    $includePath,
-                    $availableClasses
-                ));
-            }
-        }
-
-        if ($command->getPayloadSize() > 1) {
-            $parentClass = $command->getPayload()[1];
-            if ($typeToReturn instanceof ReflectionClass && $parentClass instanceof ReflectionClass) {
-                if (!$typeToReturn->isSubclassOf($parentClass->getName())) {
-                    throw new Exception(sprintf(
-                        'Class %s is not a subclass of %s',
-                        $typeToReturn->getName(),
-                        $parentClass->getName()
-                    ));
-                }
-            }
-        }
-
-        $namespaceCache = NamespacesCache::getInstance();
-        $typeCache = TypesCache::getInstance();
-
-        $typeName = $typeToReturn instanceof ReflectionClass ? $typeToReturn->getName() : (string) $typeToReturn;
-
-        $isAllowed = ($namespaceCache->isNamespaceCacheEmpty() && $typeCache->isTypeCacheEmpty())
-            || ($typeToReturn instanceof ReflectionClass && $namespaceCache->isTypeAllowed($typeToReturn))
-            || $typeCache->isTypeAllowed($typeName);
-
-        if (!$isAllowed) {
-            $allowedNamespaces = implode(', ', $namespaceCache->getCachedNamespaces());
-            $allowedTypes = implode(', ', $typeCache->getTypeCache());
-
-            $typeName = $typeToReturn instanceof ReflectionClass
-                ? $typeToReturn->getName()
-                : (string) $typeToReturn;
-
-            throw new Exception(sprintf(
-                'Type %s not allowed. Allowed namespaces: %s. Allowed types: %s',
-                $typeName,
-                $allowedNamespaces,
-                $allowedTypes
-            ));
-        }
-
-        return $typeToReturn;
-    }
-
-    private function getTypeName(CommandInterface $command): string
-    {
-        $payload = $command->getPayload()[0];
-        if (is_string($payload)) {
-            return $payload;
-        }
-
-        if ($payload instanceof ReflectionClass) {
-            return $payload->getName();
-        }
-
-        if (is_object($payload)) {
-           return get_class($payload);
-        }
-
-        return gettype($payload);
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\handler\loadLibrary\ClasspathScanner;
+use core\namespacescache\NamespacesCache;
+use core\typescache\TypesCache;
+use Exception;
+use ReflectionClass;
+use utils\CommandInterface;
+
+final class GetTypeHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+    private array $primitiveTypeMap;
+
+    public function __construct()
+    {
+        $this->primitiveTypeMap = [
+            'boolean' => 'bool',
+            'bool' => 'bool',
+            'integer' => 'int',
+            'int' => 'int',
+            'double' => 'float',
+            'float' => 'float',
+            'string' => 'string',
+            'array' => 'array',
+            'object' => 'object',
+            'resource' => 'resource',
+            'null' => 'null'
+        ];
+    }
+
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $typeName = $this->getTypeName($command);
+
+        if (array_key_exists($typeName, $this->primitiveTypeMap)) {
+            $typeToReturn = $this->primitiveTypeMap[$typeName];
+        } else {
+            try {
+                if (class_exists($typeName)) {
+                    $typeToReturn = new ReflectionClass($typeName);
+                } else {
+                    if (class_exists($typeName)) {
+                        $typeToReturn = new ReflectionClass($typeName);
+                    } else {
+                        throw new Exception('Class not found: ' . $typeName);
+                    }
+                }
+            } catch (Exception $ex) {
+                $loadedLibraries = LoadLibraryHandler::getLoadedLibraries();
+                $loadedClasses = [];
+
+                foreach ($loadedLibraries as $library) {
+                    if (substr($library, -4) === '.php' || substr($library, -5) === '.phar') {
+                        $scanner = new ClasspathScanner();
+                        $loadedClasses = array_merge(
+                            $loadedClasses,
+                            $scanner->getClassesFromFile($library)
+                        );
+                    }
+                }
+
+                $availableClasses = implode(PHP_EOL, $loadedClasses) .
+                    implode(PHP_EOL, get_declared_classes());
+
+                $includePath = get_include_path();
+
+                throw new Exception(sprintf(
+                    'Type: %s not found in include path' . PHP_EOL
+                    . 'Load all libraries at the beginning of your application' . PHP_EOL
+                    . 'Exception: %s' . PHP_EOL
+                    . 'PHP include path: %s' . PHP_EOL
+                    . 'Available classes loaded by user: %s' . PHP_EOL,
+                    $typeName,
+                    $ex->getMessage(),
+                    $includePath,
+                    $availableClasses
+                ));
+            }
+        }
+
+        if ($command->getPayloadSize() > 1) {
+            $parentClass = $command->getPayload()[1];
+            if ($typeToReturn instanceof ReflectionClass && $parentClass instanceof ReflectionClass) {
+                if (!$typeToReturn->isSubclassOf($parentClass->getName())) {
+                    throw new Exception(sprintf(
+                        'Class %s is not a subclass of %s',
+                        $typeToReturn->getName(),
+                        $parentClass->getName()
+                    ));
+                }
+            }
+        }
+
+        $namespaceCache = NamespacesCache::getInstance();
+        $typeCache = TypesCache::getInstance();
+
+        $typeName = $typeToReturn instanceof ReflectionClass ? $typeToReturn->getName() : (string) $typeToReturn;
+
+        $isAllowed = ($namespaceCache->isNamespaceCacheEmpty() && $typeCache->isTypeCacheEmpty())
+            || ($typeToReturn instanceof ReflectionClass && $namespaceCache->isTypeAllowed($typeToReturn))
+            || $typeCache->isTypeAllowed($typeName);
+
+        if (!$isAllowed) {
+            $allowedNamespaces = implode(', ', $namespaceCache->getCachedNamespaces());
+            $allowedTypes = implode(', ', $typeCache->getTypeCache());
+
+            $typeName = $typeToReturn instanceof ReflectionClass
+                ? $typeToReturn->getName()
+                : (string) $typeToReturn;
+
+            throw new Exception(sprintf(
+                'Type %s not allowed. Allowed namespaces: %s. Allowed types: %s',
+                $typeName,
+                $allowedNamespaces,
+                $allowedTypes
+            ));
+        }
+
+        return $typeToReturn;
+    }
+
+    private function getTypeName(CommandInterface $command): string
+    {
+        $payload = $command->getPayload()[0];
+        if (is_string($payload)) {
+            return $payload;
+        }
+
+        if ($payload instanceof ReflectionClass) {
+            return $payload->getName();
+        }
+
+        if (is_object($payload)) {
+           return get_class($payload);
+        }
+
+        return gettype($payload);
+    }
+}