javonet-ruby-sdk 2.6.8 → 2.6.11

data/lib/javonet-ruby-sdk/core/protocol/type_deserializer.rb

@@ -1,65 +1,65 @@
-require_relative '../../utils/string_encoding_mode_javonet'
-
-class TypeDeserializer
-  def self.deserialize_command(command_byte_array)
-    Command.new(RuntimeNameJavonet(command_byte_array[0]),
-                CommandType(command_byte_array[1]),
-                [])
-  end
-
-  def self.deserialize_string(string_encoding_mode, encoded_string)
-    raw = encoded_string.pack('C*')
-    case string_encoding_mode
-    when StringEncodingModeJavonet::ASCII
-      raw.force_encoding('US-ASCII').encode('UTF-8')
-    when StringEncodingModeJavonet::UTF8
-      raw.force_encoding('UTF-8').encode('UTF-8')
-    when StringEncodingModeJavonet::UTF16
-      raw.force_encoding('UTF-16LE').encode('UTF-8')
-    when StringEncodingModeJavonet::UTF32
-      raw.force_encoding('UTF-32').encode('UTF-8')
-    else
-      raise 'Argument out of range in deserialize_string'
-    end
-  end
-
-  def self.deserialize_int(encoded_int)
-    encoded_int.pack('C*').unpack1('l<')     # 32-bit signed LE
-  end
-
-  def self.deserialize_bool(encoded_bool)
-    encoded_bool[0] == 1
-  end
-
-  def self.deserialize_float(encoded_float)
-    encoded_float.pack('C*').unpack1('e')    # 32-bit float LE (IEEE-754)
-  end
-
-  def self.deserialize_byte(encoded_byte)
-    encoded_byte.pack('C*').unpack1('C')     # or simply encoded_byte[0]
-  end
-
-  def self.deserialize_char(encoded_char)
-    encoded_char.pack('C*').unpack1('C')     # returns codepoint 0..255
-  end
-
-  def self.deserialize_longlong(encoded_long)
-    encoded_long.pack('C*').unpack1('q<')    # 64-bit signed LE
-  end
-
-  def self.deserialize_double(encoded_double)
-    encoded_double.pack('C*').unpack1('E')   # 64-bit double LE (IEEE-754)
-  end
-
-  def self.deserialize_ullong(encoded_ullong)
-    encoded_ullong.pack('C*').unpack1('Q<')  # 64-bit unsigned LE
-  end
-
-  def self.deserialize_uint(encoded_uint)
-    encoded_uint.pack('C*').unpack1('L<')    # 32-bit unsigned LE
-  end
-
-  def self.deserialize_nil(_encoded_nil)
-    nil
-  end
-end
+require_relative '../../utils/string_encoding_mode_javonet'
+
+class TypeDeserializer
+  def self.deserialize_command(command_byte_array)
+    Command.new(RuntimeNameJavonet(command_byte_array[0]),
+                CommandType(command_byte_array[1]),
+                [])
+  end
+
+  def self.deserialize_string(string_encoding_mode, encoded_string)
+    raw = encoded_string.pack('C*')
+    case string_encoding_mode
+    when StringEncodingModeJavonet::ASCII
+      raw.force_encoding('US-ASCII').encode('UTF-8')
+    when StringEncodingModeJavonet::UTF8
+      raw.force_encoding('UTF-8').encode('UTF-8')
+    when StringEncodingModeJavonet::UTF16
+      raw.force_encoding('UTF-16LE').encode('UTF-8')
+    when StringEncodingModeJavonet::UTF32
+      raw.force_encoding('UTF-32').encode('UTF-8')
+    else
+      raise 'Argument out of range in deserialize_string'
+    end
+  end
+
+  def self.deserialize_int(encoded_int)
+    encoded_int.pack('C*').unpack1('l<')     # 32-bit signed LE
+  end
+
+  def self.deserialize_bool(encoded_bool)
+    encoded_bool[0] == 1
+  end
+
+  def self.deserialize_float(encoded_float)
+    encoded_float.pack('C*').unpack1('e')    # 32-bit float LE (IEEE-754)
+  end
+
+  def self.deserialize_byte(encoded_byte)
+    encoded_byte.pack('C*').unpack1('C')     # or simply encoded_byte[0]
+  end
+
+  def self.deserialize_char(encoded_char)
+    encoded_char.pack('C*').unpack1('C')     # returns codepoint 0..255
+  end
+
+  def self.deserialize_longlong(encoded_long)
+    encoded_long.pack('C*').unpack1('q<')    # 64-bit signed LE
+  end
+
+  def self.deserialize_double(encoded_double)
+    encoded_double.pack('C*').unpack1('E')   # 64-bit double LE (IEEE-754)
+  end
+
+  def self.deserialize_ullong(encoded_ullong)
+    encoded_ullong.pack('C*').unpack1('Q<')  # 64-bit unsigned LE
+  end
+
+  def self.deserialize_uint(encoded_uint)
+    encoded_uint.pack('C*').unpack1('L<')    # 32-bit unsigned LE
+  end
+
+  def self.deserialize_nil(_encoded_nil)
+    nil
+  end
+end

data/lib/javonet-ruby-sdk/core/protocol/type_serializer.rb

@@ -1,120 +1,120 @@
-require_relative '../../utils/type'
-require_relative '../../utils/string_encoding_mode_javonet'
-
-class TypeSerializer
-  def self.serialize_primitive(payload_item)
-    if payload_item.nil?
-      serialize_nil
-    elsif [true, false].include?(payload_item)
-      serialize_bool(payload_item)
-    elsif payload_item.is_a?(Integer)
-      if (-2**31..2**31 - 1).include?(payload_item)
-        serialize_int(payload_item)
-      elsif (-2**63..2**63 - 1).include?(payload_item)
-        serialize_longlong(payload_item)
-      else
-        serialize_ullong(payload_item)
-      end
-    elsif payload_item.is_a?(String)
-      serialize_string(payload_item)
-    elsif payload_item.is_a?(Float)
-      serialize_double(payload_item)
-    elsif payload_item.is_a?(FalseClass) || payload_item.is_a?(TrueClass)
-      serialize_bool(payload_item)
-    else
-      raise TypeError, "Unsupported payload item type: #{payload_item.class} for payload item: #{payload_item}."
-    end
-  end
-
-  def self.serialize_command(command)
-    length = int_to_bytes(command.payload.length)
-    [Type::COMMAND] + length + [command.runtime_name, command.command_type]
-  end
-
-  def self.serialize_string(string_value)
-    encoded_string_list = string_value.bytes
-    length = int_to_bytes(encoded_string_list.length)
-    [Type::JAVONET_STRING, StringEncodingModeJavonet::UTF8] + length + encoded_string_list
-  end
-
-  def self.serialize_int(int_value)
-    encoded_int_list = int_to_bytes(int_value)
-    [Type::JAVONET_INTEGER, encoded_int_list.length] + encoded_int_list
-  end
-
-  def self.serialize_bool(bool_value)
-    encoded_bool_list = bool_value ? [1] : [0]
-    [Type::JAVONET_BOOLEAN, encoded_bool_list.length] + encoded_bool_list
-  end
-
-  def self.serialize_float(float_value)
-    encoded_float_list = float_to_bytes(float_value)
-    [Type::JAVONET_FLOAT, encoded_float_list.length] + encoded_float_list
-  end
-
-  def self.serialize_byte(byte_value)
-    encoded_byte_list = [byte_value].pack('C').bytes
-    [Type::JAVONET_BYTE, encoded_byte_list.length] + encoded_byte_list
-  end
-
-  def self.serialize_char(char_value)
-    encoded_char_list = [char_value].pack('C').bytes
-    [Type::JAVONET_CHAR, encoded_char_list.length] + encoded_char_list
-  end
-
-  def self.serialize_longlong(longlong_value)
-    encoded_longlong_list = longlong_to_bytes(longlong_value)
-    [Type::JAVONET_LONG_LONG, encoded_longlong_list.length] + encoded_longlong_list
-  end
-
-  def self.serialize_double(double_value)
-    encoded_double_list = double_to_bytes(double_value)
-    [Type::JAVONET_DOUBLE, encoded_double_list.length] + encoded_double_list
-  end
-
-  def self.serialize_uint(uint_value)
-    encoded_uint_list = uint_to_bytes(uint_value)
-    [Type::JAVONET_UNSIGNED_INTEGER, encoded_uint_list.length] + encoded_uint_list
-  end
-
-  def self.serialize_ullong(ullong_value)
-    encoded_ullong_list = ullong_to_bytes(ullong_value)
-    [Type::JAVONET_UNSIGNED_LONG_LONG, encoded_ullong_list.length] + encoded_ullong_list
-  end
-
-  def self.serialize_nil
-    [Type::JAVONET_NULL, 1, 0]
-  end
-
-  # -------- pack(...).bytes helpers (little-endian) --------
-
-  # 32-bit signed int → LE bytes
-  def self.int_to_bytes(value)
-    [value].pack('l<').bytes
-  end
-
-  # 32-bit unsigned int → LE bytes
-  def self.uint_to_bytes(value)
-    [value].pack('L<').bytes
-  end
-
-  # 64-bit signed → LE bytes
-  def self.longlong_to_bytes(value)
-    [value].pack('q<').bytes
-  end
-
-  # 64-bit unsigned → LE bytes
-  def self.ullong_to_bytes(value)
-    [value].pack('Q<').bytes
-  end
-
-  # 32-bit IEEE-754 float → LE bytes
-  def self.float_to_bytes(value)
-    [value].pack('e').bytes   # little-endian float
-  end
-
-  # 64-bit IEEE-754 double → LE bytes
-  def self.double_to_bytes(value)
-    [value].pack('E').bytes   # little-endian double
-  end
-end
+require_relative '../../utils/type'
+require_relative '../../utils/string_encoding_mode_javonet'
+
+class TypeSerializer
+  def self.serialize_primitive(payload_item)
+    if payload_item.nil?
+      serialize_nil
+    elsif [true, false].include?(payload_item)
+      serialize_bool(payload_item)
+    elsif payload_item.is_a?(Integer)
+      if (-2**31..2**31 - 1).include?(payload_item)
+        serialize_int(payload_item)
+      elsif (-2**63..2**63 - 1).include?(payload_item)
+        serialize_longlong(payload_item)
+      else
+        serialize_ullong(payload_item)
+      end
+    elsif payload_item.is_a?(String)
+      serialize_string(payload_item)
+    elsif payload_item.is_a?(Float)
+      serialize_double(payload_item)
+    elsif payload_item.is_a?(FalseClass) || payload_item.is_a?(TrueClass)
+      serialize_bool(payload_item)
+    else
+      raise TypeError, "Unsupported payload item type: #{payload_item.class} for payload item: #{payload_item}."
+    end
+  end
+
+  def self.serialize_command(command)
+    length = int_to_bytes(command.payload.length)
+    [Type::COMMAND] + length + [command.runtime_name, command.command_type]
+  end
+
+  def self.serialize_string(string_value)
+    encoded_string_list = string_value.bytes
+    length = int_to_bytes(encoded_string_list.length)
+    [Type::JAVONET_STRING, StringEncodingModeJavonet::UTF8] + length + encoded_string_list
+  end
+
+  def self.serialize_int(int_value)
+    encoded_int_list = int_to_bytes(int_value)
+    [Type::JAVONET_INTEGER, encoded_int_list.length] + encoded_int_list
+  end
+
+  def self.serialize_bool(bool_value)
+    encoded_bool_list = bool_value ? [1] : [0]
+    [Type::JAVONET_BOOLEAN, encoded_bool_list.length] + encoded_bool_list
+  end
+
+  def self.serialize_float(float_value)
+    encoded_float_list = float_to_bytes(float_value)
+    [Type::JAVONET_FLOAT, encoded_float_list.length] + encoded_float_list
+  end
+
+  def self.serialize_byte(byte_value)
+    encoded_byte_list = [byte_value].pack('C').bytes
+    [Type::JAVONET_BYTE, encoded_byte_list.length] + encoded_byte_list
+  end
+
+  def self.serialize_char(char_value)
+    encoded_char_list = [char_value].pack('C').bytes
+    [Type::JAVONET_CHAR, encoded_char_list.length] + encoded_char_list
+  end
+
+  def self.serialize_longlong(longlong_value)
+    encoded_longlong_list = longlong_to_bytes(longlong_value)
+    [Type::JAVONET_LONG_LONG, encoded_longlong_list.length] + encoded_longlong_list
+  end
+
+  def self.serialize_double(double_value)
+    encoded_double_list = double_to_bytes(double_value)
+    [Type::JAVONET_DOUBLE, encoded_double_list.length] + encoded_double_list
+  end
+
+  def self.serialize_uint(uint_value)
+    encoded_uint_list = uint_to_bytes(uint_value)
+    [Type::JAVONET_UNSIGNED_INTEGER, encoded_uint_list.length] + encoded_uint_list
+  end
+
+  def self.serialize_ullong(ullong_value)
+    encoded_ullong_list = ullong_to_bytes(ullong_value)
+    [Type::JAVONET_UNSIGNED_LONG_LONG, encoded_ullong_list.length] + encoded_ullong_list
+  end
+
+  def self.serialize_nil
+    [Type::JAVONET_NULL, 1, 0]
+  end
+
+  # -------- pack(...).bytes helpers (little-endian) --------
+
+  # 32-bit signed int → LE bytes
+  def self.int_to_bytes(value)
+    [value].pack('l<').bytes
+  end
+
+  # 32-bit unsigned int → LE bytes
+  def self.uint_to_bytes(value)
+    [value].pack('L<').bytes
+  end
+
+  # 64-bit signed → LE bytes
+  def self.longlong_to_bytes(value)
+    [value].pack('q<').bytes
+  end
+
+  # 64-bit unsigned → LE bytes
+  def self.ullong_to_bytes(value)
+    [value].pack('Q<').bytes
+  end
+
+  # 32-bit IEEE-754 float → LE bytes
+  def self.float_to_bytes(value)
+    [value].pack('e').bytes   # little-endian float
+  end
+
+  # 64-bit IEEE-754 double → LE bytes
+  def self.double_to_bytes(value)
+    [value].pack('E').bytes   # little-endian double
+  end
+end

data/lib/javonet-ruby-sdk/core/receiver/{receiver_new.rb → receiver.rb}

@@ -1,42 +1,38 @@
-require_relative '../interpreter/interpreter'
-require_relative '../../utils/runtime_logger'
-require_relative '../protocol/command_serializer'
-require_relative '../../utils/command'
-require_relative '../../utils/os_helper'
-
-class Receiver
-
-  def initialize
-    puts get_runtime_info
-  end
-
-  def send_command(message_array)
-    begin
-      response_array = CommandSerializer.new.serialize(Interpreter.new.process(message_array))
-    rescue Exception => e
-      message = "Error occurred in Javonet Ruby Core: #{e.message}"
-      puts message
-      exception_command = Command.new(RuntimeNameJavonet::RUBY, CommandType::EXCEPTION, [])
-      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
-      exception_command = exception_command.add_arg_to_payload(Command.new(RuntimeNameJavonet::RUBY, CommandType::EXCEPTION, ["Ruby Core Error", "Ruby Core Error"]).to_string)
-      exception_command = exception_command.add_arg_to_payload("Ruby Core Error")
-      exception_command = exception_command.add_arg_to_payload(e.message)
-      exception_command = exception_command.add_arg_to_payload("Receiver")
-      exception_command = exception_command.add_arg_to_payload("send_command")
-      exception_command = exception_command.add_arg_to_payload("undefined")
-      exception_command = exception_command.add_arg_to_payload(__FILE__)
-      response_array = CommandSerializer.new.serialize(exception_command)
-    end
-      [response_array.length, response_array]
-  end
-
-  def heart_beat(message_array)
-    response_array = [49, 48]
-    [response_array.length, response_array]
-  end
-
-  def get_runtime_info
-    RuntimeLogger.get_runtime_info(true)
-  end
-end
-
+require_relative '../interpreter/interpreter'
+require_relative '../../utils/runtime_logger'
+require_relative '../protocol/command_serializer'
+require_relative '../../utils/command'
+require_relative '../../utils/os_helper'
+
+class Receiver
+
+  def self.send_command(message_array)
+    begin
+      response_array = CommandSerializer.serialize(Interpreter.process(message_array))
+    rescue Exception => e
+      message = "Error occurred in Javonet Ruby Core: #{e.message}"
+      puts message
+      exception_command = Command.new(RuntimeNameJavonet::RUBY, CommandType::EXCEPTION, [])
+      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
+      exception_command = exception_command.add_arg_to_payload(Command.new(RuntimeNameJavonet::RUBY, CommandType::EXCEPTION, ["Ruby Core Error", "Ruby Core Error"]).to_string)
+      exception_command = exception_command.add_arg_to_payload("Ruby Core Error")
+      exception_command = exception_command.add_arg_to_payload(e.message)
+      exception_command = exception_command.add_arg_to_payload("Receiver")
+      exception_command = exception_command.add_arg_to_payload("send_command")
+      exception_command = exception_command.add_arg_to_payload("undefined")
+      exception_command = exception_command.add_arg_to_payload(__FILE__)
+      response_array = CommandSerializer.serialize(exception_command)
+    end
+      [response_array.length, response_array]
+  end
+
+  def self.heart_beat(message_array)
+    response_array = [49, 48]
+    [response_array.length, response_array]
+  end
+
+  def self.get_runtime_info
+    RuntimeLogger.get_runtime_info(true)
+  end
+end
+

data/lib/javonet-ruby-sdk/core/reference_cache/references_cache.rb

@@ -1,39 +1,39 @@
-class ReferencesCache
-  # Make 'new' a private class method so no other instances can be created.
-  private_class_method :new
-
-  def self.instance
-    @instance ||= new
-  end
-
-  def initialize
-    @references_cache = {}
-  end
-
-  def cache_reference(object_reference)
-    uuid_ = generate_uuid
-    @references_cache[uuid_] = object_reference
-    uuid_
-  end
-
-  def resolve_reference(guid)
-    if @references_cache[guid].nil?
-      raise "Unable to resolve reference with id: #{guid}"
-    else
-      @references_cache[guid]
-    end
-  end
-
-  def delete_reference(guid)
-    if @references_cache[guid].nil?
-      raise 'Object not found in reference cache'
-    else
-      @references_cache.delete(guid)
-      0
-    end
-  end
-
-  def generate_uuid
-    [8, 4, 4, 4, 12].map { |n| rand(16**n).to_s(16).rjust(n, '0') }.join('-')
-  end
-end
+class ReferencesCache
+  # Make 'new' a private class method so no other instances can be created.
+  private_class_method :new
+
+  def self.instance
+    @instance ||= new
+  end
+
+  def initialize
+    @references_cache = {}
+  end
+
+  def cache_reference(object_reference)
+    uuid_ = generate_uuid
+    @references_cache[uuid_] = object_reference
+    uuid_
+  end
+
+  def resolve_reference(guid)
+    if @references_cache[guid].nil?
+      raise "Unable to resolve reference with id: #{guid}"
+    else
+      @references_cache[guid]
+    end
+  end
+
+  def delete_reference(guid)
+    if @references_cache[guid].nil?
+      raise 'Object not found in reference cache'
+    else
+      @references_cache.delete(guid)
+      0
+    end
+  end
+
+  def generate_uuid
+    [8, 4, 4, 4, 12].map { |n| rand(16**n).to_s(16).rjust(n, '0') }.join('-')
+  end
+end

data/lib/javonet-ruby-sdk/core/transmitter/transmitter.rb

@@ -1,58 +1,58 @@
-require 'ffi'
-require 'os'
-require_relative 'transmitter_wrapper'
-
-class Transmitter
-
-  def self.send_command(message_byte_array, message_byte_array_len)
-    message = FFI::MemoryPointer.new(:uchar, message_byte_array_len, true)
-    message.put_array_of_uchar(0, message_byte_array)
-    response_byte_array_len = TransmitterWrapper.SendCommand(message, message_byte_array_len)
-    if response_byte_array_len > 0
-      response = FFI::MemoryPointer.new(:uchar, response_byte_array_len, true)
-      TransmitterWrapper.ReadResponse(response, response_byte_array_len)
-      response_byte_array = response.get_array_of_uchar(0, response_byte_array_len)
-      return response_byte_array
-    elsif response_byte_array_len == 0
-      error_message = "Response is empty"
-      raise Exception.new error_message
-    else
-      error_message = get_native_error
-      raise Exception.new "Javonet native error code: " + response_byte_array_len.to_s + ". " + error_message
-    end
-  end
-
-  def self.activate(license_key)
-    activation_result = TransmitterWrapper.Activate(license_key)
-    if activation_result < 0
-      error_message = get_native_error
-      raise Exception.new "Javonet activation result: " + activation_result.to_s + ". Native error message: " + error_message
-    else
-      return activation_result
-    end
-  end
-
-  def self.get_native_error
-    TransmitterWrapper.GetNativeError
-  end
-
-  def self.set_config_source(config_path)
-    set_config_result = TransmitterWrapper.SetConfigSource(config_path)
-    if set_config_result < 0
-      error_message = get_native_error
-      raise Exception.new "Javonet set config source result: " + set_config_result.to_s + ". Native error message: " + error_message
-    else
-      return set_config_result
-    end
-  end
-
-  def self.set_javonet_working_directory(config_path)
-    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
-    if set_working_directory_result < 0
-      error_message = get_native_error
-      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
-    else
-      return set_working_directory_result
-    end
-  end
-end
+require 'ffi'
+require 'os'
+require_relative 'transmitter_wrapper'
+
+class Transmitter
+
+  def self.send_command(message_byte_array, message_byte_array_len)
+    message = FFI::MemoryPointer.new(:uchar, message_byte_array_len, true)
+    message.put_array_of_uchar(0, message_byte_array)
+    response_byte_array_len = TransmitterWrapper.SendCommand(message, message_byte_array_len)
+    if response_byte_array_len > 0
+      response = FFI::MemoryPointer.new(:uchar, response_byte_array_len, true)
+      TransmitterWrapper.ReadResponse(response, response_byte_array_len)
+      response_byte_array = response.get_array_of_uchar(0, response_byte_array_len)
+      return response_byte_array
+    elsif response_byte_array_len == 0
+      error_message = "Response is empty"
+      raise Exception.new error_message
+    else
+      error_message = get_native_error
+      raise Exception.new "Javonet native error code: " + response_byte_array_len.to_s + ". " + error_message
+    end
+  end
+
+  def self.activate(license_key)
+    activation_result = TransmitterWrapper.Activate(license_key)
+    if activation_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet activation result: " + activation_result.to_s + ". Native error message: " + error_message
+    else
+      return activation_result
+    end
+  end
+
+  def self.get_native_error
+    TransmitterWrapper.GetNativeError
+  end
+
+  def self.set_config_source(config_path)
+    set_config_result = TransmitterWrapper.SetConfigSource(config_path)
+    if set_config_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set config source result: " + set_config_result.to_s + ". Native error message: " + error_message
+    else
+      return set_config_result
+    end
+  end
+
+  def self.set_javonet_working_directory(config_path)
+    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
+    if set_working_directory_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
+    else
+      return set_working_directory_result
+    end
+  end
+end