hypertube-binaries 3.0.2 → 3.0.3

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

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

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

@@ -1,81 +1,81 @@
-<?php
-
-declare(strict_types=1);
-
-namespace core\handler;
-
-use Exception;
-use ReflectionClass;
-use ReflectionException;
-use utils\CommandInterface;
-
-final class GetStaticFieldHandler extends AbstractHandler
-{
-    private const REQUIRED_ARGUMENTS_COUNT = 2;
-
-    /**
-     * @return mixed
-     */
-    public function process(CommandInterface $command)
-    {
-        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
-
-        $classToLoad = $command->getPayload()[0];
-        $field = (string) $command->getPayload()[1];
-
-        try {
-            $reflectionClass = $this->getReflectionClass($classToLoad);
-
-            if ($reflectionClass->hasConstant($field)) {
-                return $reflectionClass->getConstant($field);
-            }
-
-            if (!$reflectionClass->hasProperty($field)) {
-                $this->throwFieldNotFoundException($reflectionClass, $field);
-            }
-
-            $reflectionProperty = $reflectionClass->getProperty($field);
-            if (!$reflectionProperty->isStatic()) {
-                $this->throwFieldNotFoundException($reflectionClass, $field);
-            }
-
-            $reflectionProperty->setAccessible(true);
-
-            return $reflectionProperty->getValue();
-        } catch (ReflectionException $e) {
-            $this->throwFieldNotFoundException($this->getReflectionClass($classToLoad), $field);
-        }
-    }
-
-    /**
-     * @param mixed $classToLoad
-     */
-    private function getReflectionClass($classToLoad): ReflectionClass
-    {
-        if ($classToLoad instanceof ReflectionClass) {
-            return $classToLoad;
-        }
-
-        return new ReflectionClass($classToLoad);
-    }
-
-    private function throwFieldNotFoundException(ReflectionClass $reflectionClass, string $fieldName): void
-    {
-        $message = sprintf('Static field %s not found in class %s.
-        Available static fields:' . PHP_EOL, $fieldName, $reflectionClass->getName());
-
-        $constants = $reflectionClass->getConstants();
-        foreach ($constants as $name => $value) {
-            $message .= $name . ' (constant)' . PHP_EOL;
-        }
-
-        $properties = $reflectionClass->getProperties();
-        foreach ($properties as $property) {
-            if ($property->isStatic()) {
-                $message .= $property->getName() . ' (property)' . PHP_EOL;
-            }
-        }
-
-        throw new Exception($message);
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use ReflectionClass;
+use ReflectionException;
+use utils\CommandInterface;
+
+final class GetStaticFieldHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $this->validate($command, self::REQUIRED_ARGUMENTS_COUNT, self::class);
+
+        $classToLoad = $command->getPayload()[0];
+        $field = (string) $command->getPayload()[1];
+
+        try {
+            $reflectionClass = $this->getReflectionClass($classToLoad);
+
+            if ($reflectionClass->hasConstant($field)) {
+                return $reflectionClass->getConstant($field);
+            }
+
+            if (!$reflectionClass->hasProperty($field)) {
+                $this->throwFieldNotFoundException($reflectionClass, $field);
+            }
+
+            $reflectionProperty = $reflectionClass->getProperty($field);
+            if (!$reflectionProperty->isStatic()) {
+                $this->throwFieldNotFoundException($reflectionClass, $field);
+            }
+
+            $reflectionProperty->setAccessible(true);
+
+            return $reflectionProperty->getValue();
+        } catch (ReflectionException $e) {
+            $this->throwFieldNotFoundException($this->getReflectionClass($classToLoad), $field);
+        }
+    }
+
+    /**
+     * @param mixed $classToLoad
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($classToLoad);
+    }
+
+    private function throwFieldNotFoundException(ReflectionClass $reflectionClass, string $fieldName): void
+    {
+        $message = sprintf('Static field %s not found in class %s.
+        Available static fields:' . PHP_EOL, $fieldName, $reflectionClass->getName());
+
+        $constants = $reflectionClass->getConstants();
+        foreach ($constants as $name => $value) {
+            $message .= $name . ' (constant)' . PHP_EOL;
+        }
+
+        $properties = $reflectionClass->getProperties();
+        foreach ($properties as $property) {
+            if ($property->isStatic()) {
+                $message .= $property->getName() . ' (property)' . PHP_EOL;
+            }
+        }
+
+        throw new Exception($message);
+    }
+}

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';
+    }
+}