javonet-ruby-sdk 2.5.20 → 2.6.0

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/ArrayGetSizeHandler.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Countable;
+use core\referencecache\ArrayWrapper;
+use Exception;
+use utils\CommandInterface;
+
+final class ArrayGetSizeHandler extends AbstractHandler
+{
+    public function process(CommandInterface $command): int
+    {
+        $payload = $command->getPayload();
+        if (empty($payload)) {
+            throw new Exception('Payload is empty.');
+        }
+
+        if ($payload[0] instanceof ArrayWrapper) {
+            return $this->getArraySize($payload[0]->getData());
+        }
+
+        if (is_array($payload[0])) {
+            return $this->getArraySize($payload[0]);
+        }
+
+        if ($payload[0] instanceof Countable) {
+            return count($payload[0]);
+        }
+
+        if (is_object($payload[0]) && method_exists($payload[0], 'size')) {
+            return $payload[0]->size();
+        }
+
+        if (is_object($payload[0])) {
+            throw new Exception(sprintf('Cannot get size of object of class %s', get_class($payload[0])));
+        }
+
+        throw new Exception(sprintf('Cannot get size of type %s', gettype($payload[0])));
+    }
+
+    private function getArraySize(array $array): int
+    {
+        $sizeCount = 1;
+        $currentElement = $array;
+
+        while (is_array($currentElement)) {
+            $sizeCount *= count($currentElement);
+            if (empty($currentElement)) {
+                break;
+            }
+            $currentElement = $currentElement[0];
+        }
+
+        return $sizeCount;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/ArrayHandler.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+
+final class ArrayHandler extends AbstractHandler
+{
+    public function process(CommandInterface $command): array
+    {
+        $payload = $command->getPayload();
+
+        if (empty($payload)) {
+            return [];
+        }
+
+        $processedArray = [];
+        foreach ($payload as $item) {
+            $processedArray[] = $item;
+        }
+
+        return $processedArray;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/ArraySetItemHandler.php

@@ -0,0 +1,121 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ArrayAccess;
+use core\referencecache\ArrayWrapper;
+use Exception;
+use InvalidArgumentException;
+use utils\CommandInterface;
+
+final class ArraySetItemHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 3;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $payload = $command->getPayload();
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new InvalidArgumentException(sprintf(
+                'Payload array must have at least %d elements for a set operation.',
+                self::REQUIRED_ARGUMENTS_COUNT
+            ));
+        }
+
+        if (is_array($payload[1])) {
+            return $this->setArrayElement($command);
+        }
+
+        if (is_array($payload[0]) || $payload[0] instanceof ArrayAccess) {
+            return $this->setSingleKeyElement($command);
+        }
+
+        throw new Exception(sprintf('Cannot set element on target of type %s', gettype($payload[0])));
+    }
+
+    private function setArrayElement(CommandInterface $command): int
+    {
+        $payload = $command->getPayload();
+        $array = $payload[0];
+        $indexes = $payload[1];
+        $value = $payload[2];
+
+        $actualArray = &$this->getActualArray($array);
+        $this->setNestedArrayValue($actualArray, $indexes, $value);
+
+        if (!$array instanceof ArrayWrapper) {
+            $command->setPayload(0, $actualArray);
+        }
+
+        return 0;
+    }
+
+    /**
+     * @param mixed $array
+     */
+    private function &getActualArray($array): array
+    {
+        if ($array instanceof ArrayWrapper) {
+            return $array->getData();
+        }
+
+        if (is_array($array)) {
+            return $array;
+        }
+
+        throw new InvalidArgumentException('Target is not an array or ArrayWrapper for multi-index set.');
+    }
+
+    /**
+     * @param mixed $value
+     */
+    private function setNestedArrayValue(array &$array, array $indexes, $value): void
+    {
+        if (empty($indexes)) {
+            throw new InvalidArgumentException('Indexes array cannot be empty.');
+        }
+
+        $current = &$array;
+        $lastIndex = array_pop($indexes);
+
+        foreach ($indexes as $index) {
+            if (!isset($current[$index]) || !is_array($current[$index])) {
+                $current[$index] = [];
+            }
+            $current = &$current[$index];
+        }
+
+        $current[$lastIndex] = $value;
+    }
+
+    /**
+     * @return mixed
+     */
+    private function setSingleKeyElement(CommandInterface $command)
+    {
+        $payload = $command->getPayload();
+        $target = $payload[0];
+        $key = $payload[1];
+        $value = $payload[2];
+
+        if (!(is_array($target) || $target instanceof ArrayAccess)) {
+            throw new InvalidArgumentException('Target for set operation must be an array or ArrayAccess.');
+        }
+
+        $oldValue = null;
+        if (isset($target[$key])) {
+            $oldValue = $target[$key];
+        }
+
+        $target[$key] = $value;
+
+        $command->setPayload(0, $target);
+
+        return $oldValue;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/CastHandler.php

@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use TypeError;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class CastHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        $payload = $command->getPayload();
+        if ($command->getPayloadSize() !== self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(self::class, self::REQUIRED_ARGUMENTS_COUNT);
+        }
+
+        $newType = $payload[0];
+        $value = $payload[1];
+
+        if (is_array($value) && $this->isArrayType($newType)) {
+            $newBaseType = $this->getArrayBaseType($newType);
+            $castedArray = [];
+            foreach ($value as $item) {
+                $castedArray[] = $this->castValue($newBaseType, $item);
+            }
+
+            return $castedArray;
+        }
+
+        $newBaseType = $this->isArrayType($newType) ? $this->getArrayBaseType($newType) : $newType;
+
+        return $this->castValue($newBaseType, $value);
+    }
+
+    private function isArrayType(string $type): bool
+    {
+        return substr($type, -2) === '[]';
+    }
+
+    private function getArrayBaseType(string $type): string
+    {
+        return substr($type, 0, -2);
+    }
+
+    /**
+     * @param mixed $value
+     * @return mixed
+     */
+    private function castValue(string $newBaseType, $value)
+    {
+        if (is_null($value)) {
+            return null;
+        }
+
+        if (is_object($value)) {
+            if (is_a($value, $newBaseType)) {
+                return $value;
+            }
+        }
+
+        switch (strtolower($newBaseType)) {
+            case 'byte':
+            case 'short':
+            case 'int':
+            case 'integer':
+            case 'long':
+                return (int)$value;
+            case 'float':
+            case 'double':
+                return (float)$value;
+            case 'char':
+            case 'character':
+            case 'string':
+                return (string)$value;
+            case 'bool':
+            case 'boolean':
+                return (bool)$value;
+        }
+
+        if (gettype($value) === $newBaseType) {
+            return $value;
+        }
+
+        $valueType = is_object($value) ? get_class($value) : gettype($value);
+
+        throw new TypeError('PHP Cast Handler: Cannot cast ' . $valueType . ' to ' . $newBaseType);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/ConvertTypeHandler.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+use utils\TypesHandler;
+
+final class ConvertTypeHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    public function process(CommandInterface $command): string
+    {
+        if ($command->getPayloadSize() !== self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        return TypesHandler::convertTypeToJavonetType($command->getPayload()[0]);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/CreateInstanceHandler.php

@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use Exception;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionMethod;
+use ReflectionType;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class CreateInstanceHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    /**
+     * @return object
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class, self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $payload = $command->getPayload();
+        $arguments = [];
+        try {
+            $reflectionClass = $this->getReflectionClass($payload[0]);
+            if (count($payload) === 1) {
+                return $reflectionClass->newInstance();
+            }
+
+            $arguments = array_slice($payload, 1);
+            $handlerInstance = $reflectionClass->newInstanceArgs($arguments);
+            if (null === $handlerInstance) {
+                throw new ReflectionException();
+            }
+
+            return $handlerInstance;
+        } catch (ReflectionException $e) {
+            try {
+                $className = $reflectionClass->getName();
+
+                return new $className(...$arguments);
+            } catch (Exception $fallbackException) {
+                $constructors = $reflectionClass->getConstructor();
+                $message = sprintf(
+                    'Constructor with arguments %s not found in class %s. Fallback also failed: %s',
+                    json_encode($arguments),
+                    $this->getReflectionClassName($payload[0]),
+                    $fallbackException->getMessage()
+                );
+            }
+
+            if ($constructors instanceof ReflectionMethod) {
+                $paramTypes = [];
+                foreach ($constructors->getParameters() as $param) {
+                    $paramTypes[] = $this->getParamTypeName($param->getType());
+                }
+                $message .= ' Available constructor: (' . implode(', ', $paramTypes) . ')';
+            }
+            throw new ReflectionException($message);
+        }
+    }
+
+    /**
+     * @param mixed $payload
+     */
+    private function getReflectionClass($classToLoad): ReflectionClass
+    {
+        if ($classToLoad instanceof ReflectionClass) {
+            return $classToLoad;
+        }
+
+        return new ReflectionClass($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';
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/DestructReferenceHandler.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use utils\CommandInterface;
+use core\referencecache\ReferencesCache;
+
+final class DestructReferenceHandler extends AbstractHandler
+{
+    public function process(CommandInterface $command): bool
+    {
+        return ReferencesCache::getInstance()->deleteReference((string) $command->getPayload()[0]);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/EnableNamespaceHandler.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\namespacescache\NamespacesCache;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class EnableNamespaceHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    public function process(CommandInterface $command): int
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $namespacesCache = NamespacesCache::getInstance();
+
+        foreach ($command->getPayload() as $payload) {
+            if (is_string($payload)) {
+                $namespacesCache->cacheNamespace($payload);
+            }
+
+            if (is_array($payload)) {
+                foreach ($payload as $namespaceToEnable) {
+                    if (is_string($namespaceToEnable)) {
+                        $namespacesCache->cacheNamespace($namespaceToEnable);
+                    }
+                }
+            }
+        }
+
+        return 0;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/EnableTypeHandler.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use core\typescache\TypesCache;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class EnableTypeHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 1;
+
+    public function process(CommandInterface $command): int
+    {
+        if (count($command->getPayload()) < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(self::class, self::REQUIRED_ARGUMENTS_COUNT);
+        }
+
+        $typesCache = TypesCache::getInstance();
+        foreach ($command->getPayload() as $payload) {
+            if (is_string($payload)) {
+                $typesCache->cacheType($payload);
+            }
+
+            if (is_array($payload)) {
+                foreach ($payload as $namespaceToEnable) {
+                    $typesCache->cacheType($namespaceToEnable);
+                }
+            }
+        }
+
+        return 0;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/GetInstanceFieldHandler.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionException;
+use Exception;
+use SebastianBergmann\CodeCoverage\Report\PHP;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class GetInstanceFieldHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    /**
+     * @return mixed
+     */
+    public function process(CommandInterface $command)
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $objectClass = $command->getPayload()[0];
+        $fieldString = (string)$command->getPayload()[1];
+
+        try {
+            $reflection = new ReflectionClass($objectClass);
+            if (!$reflection->hasProperty($fieldString)) {
+                throw new ReflectionException(sprintf('Property %s not found', $fieldString));
+            }
+
+            $property = $reflection->getProperty($fieldString);
+            $property->setAccessible(true);
+
+            return $property->getValue($objectClass);
+        } catch (ReflectionException $e) {
+            $reflection = new ReflectionClass($objectClass);
+            $properties = $reflection->getProperties();
+
+            $message = sprintf('Instance field %s not found in class %s . Available fields:' . PHP_EOL,
+                $fieldString,
+                get_class($objectClass)
+            );
+
+            foreach ($properties as $property) {
+                if ($property->isPublic()) {
+                    $message .= $property->getName() . PHP_EOL;
+                }
+            }
+
+            throw new Exception($message);
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/handler/GetInstanceMethodAsDelegateHandler.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace core\handler;
+
+use ReflectionClass;
+use ReflectionException;
+use ReflectionMethod;
+use utils\CommandInterface;
+use utils\exception\JavonetArgumentsMismatchException;
+
+final class GetInstanceMethodAsDelegateHandler extends AbstractHandler
+{
+    private const REQUIRED_ARGUMENTS_COUNT = 2;
+
+    public function process(CommandInterface $command): ReflectionMethod
+    {
+        if ($command->getPayloadSize() < self::REQUIRED_ARGUMENTS_COUNT) {
+            throw new JavonetArgumentsMismatchException(
+                self::class,
+                self::REQUIRED_ARGUMENTS_COUNT
+            );
+        }
+
+        $objectInstance = $command->getPayload()[0];
+        $methodToInvoke = (string) $command->getPayload()[1];
+
+        $argumentsTypes = array_slice($command->getPayload(), 2);
+
+        $reflectionClass = new ReflectionClass($objectInstance);
+
+        try {
+            return $reflectionClass->getMethod($methodToInvoke);
+        } catch (ReflectionException $e) {
+            $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);
+            $message = sprintf('Instance method %s with arguments types [%s] not found in class %s. Available methods:' . PHP_EOL,
+                $methodToInvoke,
+                implode(', ', array_map('gettype', $argumentsTypes)),
+                get_class($objectInstance)
+            );
+
+            foreach ($methods as $method) {
+                $parameters = $method->getParameters();
+                $paramTypes = array_map(function($param) {
+                    $type = $param->getType();
+
+                    return $type ? $type->getName() : 'mixed';
+                }, $parameters);
+
+                $message .= $method->getName() . ' with arguments [' .
+                    implode(', ', $paramTypes) . "]\n";
+            }
+
+            throw new ReflectionException($message, 0, $e);
+        }
+    }
+}