javonet-ruby-sdk 2.5.20 → 2.6.1

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/DynamicMethodFactory.php

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use utils\type\CommandType;
+use core\interpreter\Interpreter;
+use utils\connectiondata\InMemoryConnectionData;
+use ReflectionClass;
+
+final class DynamicMethodFactory
+{
+    public static function createDynamicClass(
+        string $className,
+        string $returnType,
+        array $paramTypes,
+        RuntimeName $callingRuntimeName,
+        string $delegateGuid
+    ): object {
+        $dynamicClass = new class($returnType, $paramTypes, $callingRuntimeName, $delegateGuid) {
+            private $returnType;
+            private $paramTypes;
+            private $callingRuntimeName;
+            private $delegateGuid;
+            
+            public function __construct($returnType, $paramTypes, $callingRuntimeName, $delegateGuid) {
+                $this->returnType = $returnType;
+                $this->paramTypes = $paramTypes;
+                $this->callingRuntimeName = $callingRuntimeName;
+                $this->delegateGuid = $delegateGuid;
+            }
+            
+            public function methodToExecute(...$args) {
+                $objArgs = [];
+                foreach ($args as $arg) {
+                    $objArgs[] = $arg;
+                }
+
+                $payload = array_merge([$this->delegateGuid], $objArgs);
+
+                $invokeDelegateCommand = new Command(
+                    $this->callingRuntimeName,
+                    CommandType::INVOKE_DELEGATE(),
+                    $payload
+                );
+
+                $interpreter = new Interpreter();
+                $executeCall = $interpreter->execute(
+                    $invokeDelegateCommand, 
+                    new InMemoryConnectionData()
+                );
+
+                $response = $executeCall->getPayload()[0];
+
+                return self::castToType($response, $this->returnType);
+            }
+            
+            private static function castToType($value, string $targetType) {
+                switch ($targetType) {
+                    case 'int':
+                    case 'integer':
+                        return (int) $value;
+                    case 'float':
+                    case 'double':
+                        return (float) $value;
+                    case 'string':
+                        return (string) $value;
+                    case 'bool':
+                    case 'boolean':
+                        return (bool) $value;
+                    case 'array':
+                        return (array) $value;
+                    case 'object':
+                        return (object) $value;
+                    default:
+                        if (class_exists($targetType)) {
+                            if ($value instanceof $targetType) {
+                                return $value;
+                            }
+
+                            $reflection = new ReflectionClass($targetType);
+                            if ($reflection->isInstantiable()) {
+                                return $reflection->newInstance($value);
+                            }
+                        }
+                        return $value;
+                }
+            }
+        };
+        
+        return $dynamicClass;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/Enum.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use utils\exception\enum\{
+    EnumNameNotFoundException,
+    InvalidEnumValueException
+};
+use ReflectionClass;
+use utils\exception\BadMethodCallException;
+
+abstract class Enum
+{
+    private int $value;
+    private static array $instances = [];
+
+    public function __construct(int $value)
+    {
+        $constants = (new ReflectionClass(static::class))->getConstants();
+        if (!in_array($value, $constants, true)) {
+            throw new InvalidEnumValueException(static::class, $value);
+        }
+
+        $this->value = $value;
+    }
+
+    public function getValue(): int
+    {
+        return $this->value;
+    }
+
+    public function getName(): string
+    {
+        foreach ((new ReflectionClass(static::class))->getConstants() as $name => $val) {
+            if ($val === $this->value) {
+                return $name;
+            }
+        }
+
+        throw new EnumNameNotFoundException((string)$this->value);
+    }
+
+    public static function __callStatic(string $method, array $arguments)
+    {
+        $className = static::class;
+        if (isset(self::$instances[$className][$method])) {
+            return self::$instances[$className][$method];
+        }
+
+        $constants = (new ReflectionClass($className))->getConstants();
+
+        if (array_key_exists($method, $constants)) {
+            $instance = new static($constants[$method]);
+            self::$instances[$className][$method] = $instance;
+            return $instance;
+        }
+
+        throw new BadMethodCallException($className, $method);
+    }
+
+    public static function from(int $value): self
+    {
+        $constants = (new ReflectionClass(static::class))->getConstants();
+        if (!in_array($value, $constants, true)) {
+            throw new InvalidEnumValueException(static::class, $value);
+        }
+
+        return new static($value);
+    }
+
+    public function equalsByValue(int $value): bool
+    {
+        return $this->value === $value;
+    }
+
+    public function notEqualsByValue(int $value): bool
+    {
+        return $this->value !== $value;
+    }
+
+    public function __toString(): string
+    {
+        return (string)$this->value;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/ExceptionSerializer.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use Throwable;
+use utils\type\CommandType;
+use utils\type\ExceptionType;
+
+final class ExceptionSerializer
+{
+    public static function serializeException(Throwable $exception, CommandInterface $command): CommandInterface
+    {
+        $exceptionCommand = new Command($command->getRuntimeName(), CommandType::EXCEPTION(), []);
+        $isDebug = false;
+
+        $stackClasses = $stackMethods = $stackLines = $stackFiles = '';
+
+        $trace = $exception->getTrace();
+        if (!$isDebug) {
+            $trace = self::getStackTraceAfterReflection($trace);
+        }
+
+        self::serializeStackTrace($trace, $stackClasses, $stackMethods, $stackLines, $stackFiles);
+
+        $exceptionName = basename(str_replace('\\', '/', get_class($exception)));
+
+        $exceptionCommand = $exceptionCommand->addArgToPayload(ExceptionType::getExceptionCodeByExceptionName($exceptionName));
+        $exceptionCommand = $exceptionCommand->addArgToPayload($command);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($exceptionName);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($exception->getMessage());
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackClasses);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackMethods);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackLines);
+        $exceptionCommand = $exceptionCommand->addArgToPayload($stackFiles);
+
+        return $exceptionCommand;
+    }
+
+    private static function serializeStackTrace(
+        array $trace,
+        string &$stackClasses,
+        string &$stackMethods,
+        string &$stackLines,
+        string &$stackFiles
+    ): void {
+        foreach ($trace as $frame) {
+            $stackClasses .= ($frame['class'] ?? 'undefined') . '|';
+            $stackMethods .= ($frame['function'] ?? 'undefined') . '|';
+            $stackLines .= ($frame['line'] ?? '0') . '|';
+            $stackFiles .= ($frame['file'] ?? 'undefined') . '|';
+        }
+    }
+
+    private static function getStackTraceAfterReflection(array $trace): array
+    {
+        $index = 0;
+        foreach ($trace as $frame) {
+            $class = $frame['class'] ?? '';
+            if (strpos($class, 'javonet') !== false || strpos($class, 'Reflector') !== false) {
+                break;
+            }
+            $index++;
+        }
+
+        return array_slice($trace, 0, $index);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/RuntimeLogger.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use Exception;
+
+final class RuntimeLogger {
+    private static bool $notLoggedYet = true;
+
+    public static function getRuntimeInfo(): string
+    {
+        try {
+            return sprintf(
+                "PHP Managed Runtime Info:\n" .
+                "PHP Version: %s\n" .
+                "PHP executable path: %s\n" .
+                "PHP Path: %s\n" .
+                "PHP Implementation: %s\n" .
+                "OS Version: %s %s\n" .
+                "Process Architecture: %s\n" .
+                "Current Working Directory: %s\n",
+                PHP_VERSION,
+                PHP_BINARY,
+                get_include_path(),
+                PHP_SAPI,
+                PHP_OS_FAMILY,
+                php_uname('r'),
+                php_uname('m'),
+                getcwd()
+            );
+        } catch (Exception $e) {
+            return 'PHP Managed Runtime Info: Error while fetching runtime info';
+        }
+    }
+
+    public static function displayRuntimeInfo(): void
+    {
+        if (self::$notLoggedYet) {
+            echo self::getRuntimeInfo();
+            self::$notLoggedYet = false;
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/RuntimeName.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+final class RuntimeName extends Enum
+{
+    public const CLR = 0;
+    public const GO = 1;
+    public const JVM = 2;
+    public const NETCORE = 3;
+    public const PERL = 4;
+    public const PYTHON = 5;
+    public const RUBY = 6;
+    public const NODEJS = 7;
+    public const CPP = 8;
+    public const PHP = 9;
+    public const PYTHON27 = 10;
+    public const NONE = 11;
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/RuntimeNameHandler.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+final class RuntimeNameHandler
+{
+    public static function getName(RuntimeName $runtimeName): string
+    {
+        switch ($runtimeName->getValue()) {
+            case RuntimeName::CLR:
+                return 'clr';
+            case RuntimeName::GO:
+                return 'go';
+            case RuntimeName::JVM:
+                return 'jvm';
+            case RuntimeName::NETCORE:
+                return 'netcore';
+            case RuntimeName::PERL:
+                return 'perl';
+            case RuntimeName::PYTHON:
+                return 'python';
+            case RuntimeName::RUBY:
+                return 'ruby';
+            case RuntimeName::NODEJS:
+                return 'nodejs';
+            case RuntimeName::CPP:
+                return 'cpp';
+            case RuntimeName::PHP:
+                return 'php';
+            case RuntimeName::PYTHON27:
+                return 'python27';
+            case RuntimeName::NONE:
+                return 'none';
+            default:
+                 throw new \Exception('Invalid runtime name.');
+        }
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/StringEncodingMode.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+final class StringEncodingMode extends Enum
+{
+    public const JAVONET_ASCII = 0;
+    public const JAVONET_UTF8 = 1;
+    public const JAVONET_UTF16 = 2;
+    public const JAVONET_UTF32 = 3;
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/TypesHandler.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use ReflectionType;
+use utils\type\JType;
+
+final class TypesHandler
+{
+    private function __construct()
+    {
+    }
+
+    public static function convertTypeToJavonetType(ReflectionType $type): string
+    {
+        $typeName = $type->getName();
+        switch ($typeName) {
+            case 'bool':
+                return JType::JAVONET_BOOLEAN()->getName();
+            case 'string':
+                return JType::JAVONET_STRING()->getName();
+            case 'char':
+                return JType::JAVONET_CHAR()->getName();
+            case 'int':
+                return JType::JAVONET_INT()->getName();
+            case 'float':
+                return JType::JAVONET_FLOAT()->getName();
+            case 'double':
+                return JType::JAVONET_DOUBLE()->getName();
+            case 'null':
+                return JType::JAVONET_NULL()->getName();
+            default:
+                return $typeName;
+        }
+    }
+
+
+    /**
+     * @param mixed $item
+     */
+    public static function isSimpleType($item): bool
+    {
+        return $item === null || is_scalar($item)
+            || (is_object($item) && in_array(get_class($item), [
+                    'string', 'int', 'float', 'bool', 'double', 'null'
+                ], true));
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/Uri.php

@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use utils\exception\InvalidUriException;
+
+final class Uri {
+    private ?string $scheme;
+    private ?string $host;
+    private ?int $port;
+    private ?string $user;
+    private ?string $pass;
+    private ?string $path;
+    private ?string $query;
+    private ?string $fragment;
+
+    public function __construct(string $uri)
+    {
+        $this->parseUri($uri);
+    }
+
+    private function parseUri(string $uri): void
+    {
+        $parsedUri = parse_url($uri);
+        if ($parsedUri === false) {
+            throw new InvalidUriException($uri);
+        }
+
+        if (UtilsArray::hasNotValues($parsedUri)) {
+            throw new InvalidUriException($uri);
+        }
+
+        $this->scheme = $parsedUri['scheme'] ?? null;
+        $this->host = $parsedUri['host'] ?? null;
+        $this->port = $parsedUri['port'] ?? null;
+        $this->user = $parsedUri['user'] ?? null;
+        $this->pass = $parsedUri['pass'] ?? null;
+        $this->path = $parsedUri['path'] ?? null;
+        $this->query = $parsedUri['query'] ?? null;
+        $this->fragment = $parsedUri['fragment'] ?? null;
+    }
+
+    public function getScheme(): ?string
+    {
+        return $this->scheme;
+    }
+
+    public function getHost(): ?string
+    {
+        return $this->host;
+    }
+
+    public function getPort(): ?int
+    {
+        return $this->port;
+    }
+
+    public function isNotEmptyPort(): bool
+    {
+        return !empty($this->port);
+    }
+
+    public function getUser(): ?string
+    {
+        return $this->user;
+    }
+
+    public function getPass(): ?string
+    {
+        return $this->pass;
+    }
+
+    public function getPath(): ?string
+    {
+        return $this->path;
+    }
+
+    public function isEmptyPath(): bool
+    {
+        return empty($this->path);
+    }
+
+    public function getQuery(): ?string
+    {
+        return $this->query;
+    }
+
+    public function getFragment(): ?string
+    {
+        return $this->fragment;
+    }
+
+    public function __toString(): string
+    {
+        return $this->toString();
+    }
+
+    public function toString(): string
+    {
+        $uri = '';
+        if ($this->scheme) {
+            $uri .= $this->scheme . '://';
+        }
+
+        if ($this->user) {
+            $uri .= $this->user;
+
+            if ($this->pass) {
+                $uri .= ':' . $this->pass;
+            }
+
+            $uri .= '@';
+        }
+
+        if ($this->host) {
+            $uri .= $this->host;
+        }
+
+        if ($this->port) {
+            $uri .= ':' . $this->port;
+        }
+
+        if ($this->path) {
+            $uri .= $this->path;
+        }
+
+        if ($this->query) {
+            $uri .= '?' . $this->query;
+        }
+
+        if ($this->fragment) {
+            $uri .= '#' . $this->fragment;
+        }
+
+        return $uri;
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/UtilsArray.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+final class UtilsArray
+{
+    public static function hasNotValues(array $array): bool
+    {
+        $filtered = array_filter($array, function ($value) {
+            return is_array($value) ? self::hasNotValues($value) : !empty($value);
+        });
+
+        return empty($filtered);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/UtilsConst.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+use RuntimeException;
+
+final class UtilsConst
+{
+    private static string $configSource = '';
+    private static string $licenseKey = '';
+    private static string $javonetWorkingDirectory = '';
+
+    public static function getLicenseKey(): string
+    {
+        return self::$licenseKey;
+    }
+
+    public static function setLicenseKey(?string $value): void
+    {
+        if (empty($value) || $value === 'your-license-key') {
+            return;
+        }
+
+        self::$licenseKey = $value;
+    }
+
+    public static function getJavonetWorkingDirectory(): string
+    {
+         if (empty(self::$javonetWorkingDirectory)) {
+            return self::$javonetWorkingDirectory = getcwd() . '/';
+         }
+
+        return self::$javonetWorkingDirectory;
+    }
+
+    public static function setJavonetWorkingDirectory(string $value): void
+    {
+        $path = str_replace('\\', '/', $value);
+        if (substr($path, -1) !== '/') {
+            $path .= '/';
+        }
+
+        if (!is_dir($path)) {
+            if (!mkdir($path, 0700, true)) {
+                throw new RuntimeException('Unable to create directory: ' . $path);
+            }
+        }
+
+        if (!is_writable($path)) {
+            throw new RuntimeException('Directory is not writable: ' . $path);
+        }
+
+        self::$javonetWorkingDirectory = $path;
+    }
+
+    public static function setConfigSource(string $value): void
+    {
+        self::$configSource = $value;
+    }
+
+    public static function getConfigSource(): string
+    {
+        return self::$configSource;
+    }
+
+    public static function isNotEmptyConfigSource(): bool
+    {
+        return !empty(self::$configSource);
+    }
+}

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/utils/UtilsSimpleType.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace utils;
+
+final class UtilsSimpleType
+{
+    private function __construct()
+    {
+    }
+
+    public static function isFloat($value): bool
+    {
+        return is_float($value) && self::getDecimalPrecision($value) <= 6;
+    }
+
+    public static function isChar($value): bool
+    {
+        return is_string($value) && strlen($value) === 1;
+    }
+
+    public static function isByte($value): bool
+    {
+        return is_int($value) && $value >= -128 && $value <= 127;
+    }
+
+    public static function isInteger($value): bool
+    {
+        return is_int($value) && $value >= -2147483648 && $value <= 2147483647;
+    }
+
+    public static function isLong($value): bool
+    {
+        return is_int($value) && $value >= -9223372036854775808 && $value <= 9223372036854775807;
+    }
+
+    public static function getDecimalPrecision(float $number): int
+    {
+        $str = (string) $number;
+        $decimalPos = strpos($str, '.');
+        if ($decimalPos === false) {
+            return 0;
+        }
+
+        return strlen($str) - $decimalPos - 1;
+    }
+}