javonet-ruby-sdk 2.6.10 → 2.6.11

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

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

@@ -1,32 +1,32 @@
-module TransmitterWrapper
-  extend FFI::Library
-
-  arch = case FFI::Platform::ARCH
-         when 'x86_64'
-           'X64'
-         when 'x86'
-           'X86'
-         when 'arm'
-           'ARM'
-         when 'aarch64'
-           'ARM64'
-         else
-           raise "Unsupported architecture: #{FFI::Platform::ARCH}"
-         end
-
-  if OS.linux?
-    ffi_lib File.expand_path("../../../Binaries/Native/Linux/#{arch}/libJavonetRubyRuntimeNative.so", __FILE__)
-  elsif OS.mac?
-    ffi_lib File.expand_path("../../../Binaries/Native/MacOs/#{arch}/libJavonetRubyRuntimeNative.dylib", __FILE__)
-  else
-    RubyInstaller::Runtime.add_dll_directory(File.expand_path("../../../Binaries/Native/Windows/#{arch}/", __FILE__))
-    ffi_lib File.expand_path("../../../Binaries/Native/Windows/#{arch}/JavonetRubyRuntimeNative.dll", __FILE__)
-  end
-
-  attach_function :SendCommand, [:pointer, :int], :int
-  attach_function :ReadResponse, [:pointer, :int], :int
-  attach_function :Activate, [:pointer], :int
-  attach_function :GetNativeError, [], :string
-  attach_function :SetConfigSource, [:pointer], :int
-  attach_function :SetWorkingDirectory, [:pointer], :int
+module TransmitterWrapper
+  extend FFI::Library
+
+  arch = case FFI::Platform::ARCH
+         when 'x86_64'
+           'X64'
+         when 'x86'
+           'X86'
+         when 'arm'
+           'ARM'
+         when 'aarch64'
+           'ARM64'
+         else
+           raise "Unsupported architecture: #{FFI::Platform::ARCH}"
+         end
+
+  if OS.linux?
+    ffi_lib File.expand_path("../../../Binaries/Native/Linux/#{arch}/libJavonetRubyRuntimeNative.so", __FILE__)
+  elsif OS.mac?
+    ffi_lib File.expand_path("../../../Binaries/Native/MacOs/#{arch}/libJavonetRubyRuntimeNative.dylib", __FILE__)
+  else
+    RubyInstaller::Runtime.add_dll_directory(File.expand_path("../../../Binaries/Native/Windows/#{arch}/", __FILE__))
+    ffi_lib File.expand_path("../../../Binaries/Native/Windows/#{arch}/JavonetRubyRuntimeNative.dll", __FILE__)
+  end
+
+  attach_function :SendCommand, [:pointer, :int], :int
+  attach_function :ReadResponse, [:pointer, :int], :int
+  attach_function :Activate, [:pointer], :int
+  attach_function :GetNativeError, [], :string
+  attach_function :SetConfigSource, [:pointer], :int
+  attach_function :SetWorkingDirectory, [:pointer], :int
 end

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

@@ -1,42 +1,42 @@
-class TypeCache
-  attr_accessor :type_cache
-
-  def self.instance
-    @instance ||= new
-  end
-
-  private_class_method :new
-
-  def initialize
-    @type_cache = []
-  end
-
-  def cache_type(type_regex)
-    @type_cache << type_regex
-  end
-
-  def is_type_cache_empty?
-    @type_cache.empty?
-  end
-
-  def is_type_allowed(type_to_check)
-    name_to_check = if type_to_check.is_a?(Module)
-                      type_to_check.name
-                    else
-                      "#{type_to_check.class.name}::#{type_to_check.name}"
-                    end
-
-    @type_cache.any? do |pattern|
-      /#{pattern}/.match?(name_to_check)
-    end
-  end
-
-  def get_cached_types
-    @type_cache
-  end
-
-  def clear_cache
-    @type_cache.clear
-    0
-  end
+class TypeCache
+  attr_accessor :type_cache
+
+  def self.instance
+    @instance ||= new
+  end
+
+  private_class_method :new
+
+  def initialize
+    @type_cache = []
+  end
+
+  def cache_type(type_regex)
+    @type_cache << type_regex
+  end
+
+  def is_type_cache_empty?
+    @type_cache.empty?
+  end
+
+  def is_type_allowed(type_to_check)
+    name_to_check = if type_to_check.is_a?(Module)
+                      type_to_check.name
+                    else
+                      "#{type_to_check.class.name}::#{type_to_check.name}"
+                    end
+
+    @type_cache.any? do |pattern|
+      /#{pattern}/.match?(name_to_check)
+    end
+  end
+
+  def get_cached_types
+    @type_cache
+  end
+
+  def clear_cache
+    @type_cache.clear
+    0
+  end
 end