javonet-ruby-sdk 2.6.7 → 2.6.8

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/protocol/CommandDeserializer.php

@@ -14,81 +14,90 @@ use utils\type\JType;
 
 final class CommandDeserializer
 {
-    private int $position;
-    private Command $command;
-    private array $buffer;
-
-    public function __construct(
-         array $buffer
-    ) {
-        $this->command = new Command(
-            new RuntimeName($buffer[0]),
-            new CommandType($buffer[10])
-        );
-        $this->buffer = $buffer;
-        $this->position = 11;
-    }
-
-    private function isNotEnd(): bool
+    private function __construct()
     {
-        return $this->position < count($this->buffer);
     }
 
-    public function deserialize(): CommandInterface
+    /**
+     * @param int[] $buffer
+     */
+    public static function deserialize(array $buffer): CommandInterface
     {
-        while ($this->isNotEnd()) {
-            $this->command = $this->command->addArgToPayload($this->readObject($this->buffer[$this->position]));
+        $position = 11;
+        $bufferLength = count($buffer);
+
+        $runtimeName = new RuntimeName($buffer[0]);
+        $commandType = new CommandType($buffer[10]);
+        $payload = [];
+
+        while ($position < $bufferLength) {
+            $payload[] = self::readObject($buffer, $position);
         }
 
-        return $this->command;
+        // Single Command instance created once with full payload
+        return new Command($runtimeName, $commandType, $payload);
     }
 
-    private function readObject(int $typeNum)
+    /**
+     * @param int[] $buffer
+     * @return mixed
+     */
+    private static function readObject(array $buffer, int &$position)
     {
-        $typeByte = new JType($typeNum);
+        $typeByte = new JType($buffer[$position]);
 
         switch ($typeByte->getValue()) {
             case JType::JAVONET_COMMAND:
-                return $this->readCommand();
+                return self::readCommand($buffer, $position);
             case JType::JAVONET_STRING:
-                return $this->readString();
+                return self::readString($buffer, $position);
             case JType::JAVONET_INTEGER:
-                return $this->readInt();
+                return self::readInt($buffer, $position);
             case JType::JAVONET_BOOLEAN:
-                return $this->readBool();
+                return self::readBool($buffer, $position);
             case JType::JAVONET_FLOAT:
-                return $this->readFloat();
+                return self::readFloat($buffer, $position);
             case JType::JAVONET_BYTE:
-                return $this->readByte();
+                return self::readByte($buffer, $position);
             case JType::JAVONET_CHAR:
-                return $this->readChar();
+                return self::readChar($buffer, $position);
             case JType::JAVONET_LONG:
-                return $this->readLong();
+                return self::readLong($buffer, $position);
             case JType::JAVONET_DOUBLE:
-                return $this->readDouble();
+                return self::readDouble($buffer, $position);
             case JType::JAVONET_UNSIGNED_LONG_LONG:
-                return $this->readUnsignedLong();
+                return self::readUnsignedLong($buffer, $position);
             case JType::JAVONET_UNSIGNED_INTEGER:
-                return $this->readUnsignedInteger();
+                return self::readUnsignedInteger($buffer, $position);
             case JType::JAVONET_NULL:
-                return $this->readNull();
+                return self::readNull($buffer, $position);
             default:
-                throw new TypeByteNotSupportedException($typeNum);
+                throw new TypeByteNotSupportedException($buffer[$position]);
         }
     }
 
-    protected function readCommand(): CommandInterface
+    /**
+     * @param int[] $buffer
+     */
+    protected static function readCommand(array $buffer, int &$position): CommandInterface
     {
-        $p = $this->position;
-        $numberOfElementsInPayload = TypeDeserializer::deserializeInt(array_slice($this->buffer, $p + 1, 4));
-        $runtime = $this->buffer[$p + 5];
-        $commandType = $this->buffer[$p + 6];
+        $p = $position;
+
+        $numberOfElementsInPayload = TypeDeserializer::deserializeInt([
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+        ]);
+
+        $runtime     = $buffer[$p + 5];
+        $commandType = $buffer[$p + 6];
 
-        $this->position += 7;
+        $position += 7;
 
         $payload = [];
         for ($i = 0; $i < $numberOfElementsInPayload; $i++) {
-            $payload[$i] = $this->readObject($this->buffer[$this->position]);
+            $payload[$i] = self::readObject($buffer, $position);
         }
 
         return new Command(
@@ -98,114 +107,218 @@ final class CommandDeserializer
         );
     }
 
-    private function readString(): string
+    /**
+     * @param int[] $buffer
+     */
+    private static function readString(array $buffer, int &$position): string
     {
-        $p = $this->position;
-        $stringEncodingMode = new StringEncodingMode($this->buffer[$p + 1]);
-        $size = TypeDeserializer::deserializeInt(array_slice($this->buffer, $p + 2, 4));
-        $this->position += 6;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeString($stringEncodingMode, array_slice($this->buffer, $p, $size));
+        $p = $position;
+
+        $stringEncodingMode = new StringEncodingMode($buffer[$p + 1]);
+
+        $size = TypeDeserializer::deserializeInt([
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+        ]);
+
+        $position += 6;
+        $p = $position;
+        $position += $size;
+
+        // For strings, size can be large, so array_slice is acceptable here.
+        $bytes = array_slice($buffer, $p, $size);
+
+        return TypeDeserializer::deserializeString($stringEncodingMode, $bytes);
     }
 
-    private function readInt(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readInt(array $buffer, int &$position): int
     {
         $size = 4;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeInt(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+        ];
+
+        return TypeDeserializer::deserializeInt($bytes);
     }
 
-    private function readBool(): bool
+    /**
+     * @param int[] $buffer
+     */
+    private static function readBool(array $buffer, int &$position): bool
     {
         $size = 1;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        // Keep passing array to match existing TypeDeserializer signature
+        $bytes = [$buffer[$p]];
 
-        return TypeDeserializer::deserializeBool(array_slice($this->buffer, $p, $size));
+        return TypeDeserializer::deserializeBool($bytes);
     }
 
-    private function readFloat(): float
+    /**
+     * @param int[] $buffer
+     */
+    private static function readFloat(array $buffer, int &$position): float
     {
         $size = 4;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeFloat(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+        ];
+
+        return TypeDeserializer::deserializeFloat($bytes);
     }
 
-    private function readByte(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readByte(array $buffer, int &$position): int
     {
         $size = 1;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
+        $position += 2;
+        $p = $position;
+        $position += $size;
 
-        return TypeDeserializer::deserializeByte($this->buffer[$p]);
+        return TypeDeserializer::deserializeByte($buffer[$p]);
     }
 
-    private function readChar(): string
+    /**
+     * @param int[] $buffer
+     */
+    private static function readChar(array $buffer, int &$position): string
     {
         $size = 1;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
+        $position += 2;
+        $p = $position;
+        $position += $size;
 
-        return TypeDeserializer::deserializeChar($this->buffer[$p]);
+        return TypeDeserializer::deserializeChar($buffer[$p]);
     }
 
-    private function readLong(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readLong(array $buffer, int &$position): int
     {
         $size = 8;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeLong(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+            $buffer[$p + 6],
+            $buffer[$p + 7],
+        ];
+
+        return TypeDeserializer::deserializeLong($bytes);
     }
 
-    private function readDouble(): float
+    /**
+     * @param int[] $buffer
+     */
+    private static function readDouble(array $buffer, int &$position): float
     {
         $size = 8;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeDouble(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+            $buffer[$p + 6],
+            $buffer[$p + 7],
+        ];
+
+        return TypeDeserializer::deserializeDouble($bytes);
     }
 
-    private function readUnsignedLong(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readUnsignedLong(array $buffer, int &$position): int
     {
         $size = 8;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeLong(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+            $buffer[$p + 4],
+            $buffer[$p + 5],
+            $buffer[$p + 6],
+            $buffer[$p + 7],
+        ];
+
+        return TypeDeserializer::deserializeLong($bytes);
     }
 
-    private function readUnsignedInteger(): int
+    /**
+     * @param int[] $buffer
+     */
+    private static function readUnsignedInteger(array $buffer, int &$position): int
     {
         $size = 4;
-        $this->position += 2;
-        $p = $this->position;
-        $this->position += $size;
-
-        return TypeDeserializer::deserializeInt(array_slice($this->buffer, $p, $size));
+        $position += 2;
+        $p = $position;
+        $position += $size;
+
+        $bytes = [
+            $buffer[$p],
+            $buffer[$p + 1],
+            $buffer[$p + 2],
+            $buffer[$p + 3],
+        ];
+
+        return TypeDeserializer::deserializeInt($bytes);
     }
 
-    private function readNull()
+    /**
+     * @param int[] $buffer
+     * @return mixed
+     */
+    private static function readNull(array $buffer, int &$position)
     {
         $size = 1;
-        $this->position += 2;
-        $this->position += $size;
+        $position += 2;
+        $position += $size;
 
+        // Current TypeDeserializer::deserializeNull() in your PHP version
+        // takes no args; keep that behavior.
         return TypeDeserializer::deserializeNull();
     }
 }

data/lib/javonet-ruby-sdk/Binaries/Php/javonet/core/protocol/CommandSerializer.php

@@ -16,53 +16,95 @@ use utils\TypesHandler;
 
 final class CommandSerializer
 {
+    private const DEFAULT_SERIALIZER_CONNECTION_DATA = [0, 0, 0, 0, 0, 0, 0];
+
     private function __construct()
     {
     }
 
-    private const DEFAULT_SERIALIZER_CONNECTION_DATA = [0, 0, 0, 0, 0, 0, 0];
-
+    /**
+     * Serialize command to array of bytes (ints 0–255).
+     *
+     * @return int[]
+     */
     public static function serialize(CommandInterface $rootCommand, ?IConnectionData $connectionData): array
     {
         try {
+            $buffer = [];
+
+            // Write runtime and version
             $buffer[] = $rootCommand->getRuntimeName()->getValue();
             $buffer[] = 0; // runtimeVersion
-            array_push($buffer, ...self::getDataByConnectionData($connectionData));
-            $buffer[] = RuntimeName::PHP;
-            $buffer[] = $rootCommand->getCommandType()->getValue();
 
+            // Write connection data
+            self::insertIntoBuffer($buffer, self::getDataByConnectionData($connectionData));
+
+            // Write runtime name and command type header for PHP runtime
+            self::insertIntoBuffer($buffer, [
+                RuntimeName::PHP,
+                $rootCommand->getCommandType()->getValue(),
+            ]);
+
+            // Serialize payload recursively
             self::serializeRecursively($rootCommand, $buffer);
 
             return $buffer;
         } catch (Exception $e) {
-            throw new RuntimeException('Error during serialization ' . $e);
+            throw new RuntimeException(
+                'Error during serialization: ' . $e->getMessage(),
+                0,
+                $e
+            );
         }
     }
 
+    /**
+     * @return int[]
+     */
     private static function getDataByConnectionData(?IConnectionData $connectionData): array
     {
-        if (null !== $connectionData) {
+        if ($connectionData !== null) {
             return $connectionData->serializeConnectionData();
         }
 
         return self::DEFAULT_SERIALIZER_CONNECTION_DATA;
     }
 
+    /**
+     * @param int[] $buffer
+     * @param int[] $data
+     */
+    private static function insertIntoBuffer(array &$buffer, array $data): void
+    {
+        foreach ($data as $value) {
+            $buffer[] = $value;
+        }
+    }
+
+    /**
+     * @param int[] $buffer
+     */
     private static function serializeRecursively(CommandInterface $command, array &$buffer): void
     {
         foreach ($command->getPayload() as $payloadItem) {
             if ($payloadItem instanceof CommandInterface) {
-                array_push($buffer, ...TypeSerializer::serializeCommand($payloadItem));
+                // Nested command
+                self::insertIntoBuffer($buffer, TypeSerializer::serializeCommand($payloadItem));
                 self::serializeRecursively($payloadItem, $buffer);
-            } else if (TypesHandler::isSimpleType($payloadItem)) {
-                array_push($buffer, ...TypeSerializer::serializePrimitive($payloadItem));
+            } elseif (TypesHandler::isSimpleType($payloadItem)) {
+                // Primitive or simple type
+                self::insertIntoBuffer($buffer, TypeSerializer::serializePrimitive($payloadItem));
             } else {
+                // Complex object – serialize as reference command
+                $referenceId = ReferencesCache::getInstance()->cacheReference($payloadItem);
+
                 $refCommand = new Command(
-                    $command->getRuntimeName(),
+                    new RuntimeName(RuntimeName::PHP),
                     CommandType::REFERENCE(),
-                    ReferencesCache::getInstance()->cacheReference($payloadItem)
+                    $referenceId
                 );
-                array_push($buffer, ...TypeSerializer::serializeCommand($refCommand));
+
+                self::insertIntoBuffer($buffer, TypeSerializer::serializeCommand($refCommand));
                 self::serializeRecursively($refCommand, $buffer);
             }
         }

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

@@ -11,18 +11,23 @@ final class Command implements CommandInterface
 {
     private RuntimeName $runtimeName;
     private CommandType $commandType;
+    /** @var array<mixed> */
     private array $payload;
 
     public function __construct(
         RuntimeName $runtimeName,
         CommandType $commandType,
-        ...$payload
+                    ...$payload
     ) {
         $this->runtimeName = $runtimeName;
         $this->commandType = $commandType;
-        $this->payload = count($payload) === 1 && is_array($payload[0])
-            ? $payload[0]
-            : $payload;
+
+        // If a single array is passed, treat it as the payload itself.
+        if (count($payload) === 1 && is_array($payload[0])) {
+            $this->payload = $payload[0];
+        } else {
+            $this->payload = $payload;
+        }
     }
 
     /**
@@ -30,7 +35,11 @@ final class Command implements CommandInterface
      */
     public function addArgToPayload($arg): CommandInterface
     {
-        return new Command($this->runtimeName, $this->commandType, array_merge($this->payload, [$arg]));
+        // Keep semantics (return new Command) but avoid array_merge overhead.
+        $newPayload = $this->payload;
+        $newPayload[] = $arg;
+
+        return new Command($this->runtimeName, $this->commandType, $newPayload);
     }
 
     /**
@@ -51,6 +60,9 @@ final class Command implements CommandInterface
         return $this->commandType;
     }
 
+    /**
+     * @return array<mixed>
+     */
     public function getPayload(): array
     {
         return $this->payload;
@@ -84,14 +96,14 @@ final class Command implements CommandInterface
             $result .= ' CommandType: ';
             $result .= $this->commandType->getName();
             $result .= ' Payload: ';
-            json_encode($this->payload);
+            $result .= json_encode($this->payload);
 
             return $result;
         } catch (Exception $e) {
             return 'Error while converting command to string: ' . $e->getMessage();
         }
     }
-    
+
     /**
      * @param mixed $response
      */
@@ -116,7 +128,11 @@ final class Command implements CommandInterface
             return new self($this->runtimeName, $this->commandType, $this->payload);
         }
 
-        return new self($this->runtimeName, $this->commandType, [$currentCommand, ...$this->payload]);
+        return new self(
+            $this->runtimeName,
+            $this->commandType,
+            [$currentCommand, ...$this->payload]
+        );
     }
 
     /**
@@ -147,15 +163,17 @@ final class Command implements CommandInterface
                 if (!$payloadItem->equals($elementPayloadItem)) {
                     return false;
                 }
+                continue;
             }
 
             if (is_object($payloadItem) && method_exists($payloadItem, 'equals') && is_object($elementPayloadItem)) {
                 if (!$payloadItem->equals($elementPayloadItem)) {
                     return false;
                 }
+                continue;
             }
 
-            elseif ($payloadItem !== $elementPayloadItem) {
+            if ($payloadItem !== $elementPayloadItem) {
                 return false;
             }
         }

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/core/handler/GetTypeHandler.py

@@ -47,7 +47,7 @@ class GetTypeHandler(AbstractCommandHandler):
             exc_type, exc_value = type(e), e
             sys_path = "\n".join(sys.path)
             available_types = "\n".join(self.get_all_available_types())
-            new_message = str(e) + "\nMake sure to install python packages in one of this directories:\n" + sys_path  + "\n\nAvailable user types:\n" + available_types + "\n\n"
+            new_message = str(e) + "\nMake sure that your python solution is in one of this directories:\n" + sys_path  + "\n\nAvailable user types:\n" + available_types + "\n\n"
             new_exc = exc_type(new_message).with_traceback(e.__traceback__)
             raise new_exc from None
 
@@ -75,7 +75,7 @@ class GetTypeHandler(AbstractCommandHandler):
     def get_all_available_types(self):
         """Get all available types without loading/executing any modules."""
         available_types = set()
-        for directory in LoadLibraryHandler.loaded_directories:
+        for directory in LoadLibraryHandler.loaded_dir_and_files:
             for root, _, files in os.walk(directory):
                 if "Binaries" in root:
                     continue