javonet-ruby-sdk 2.6.0 → 2.6.2

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/protocol/type_deserializer.rb

@@ -1,126 +0,0 @@
-require_relative '../../utils/string_encoding_mode'
-
-class TypeDeserializer
-
-  def self.deserialize_command(command_byte_array)
-    Command.new(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
-  end
-
-  def self.deserialize_string(string_encoding_mode, encoded_string)
-    raw_str = encoded_string.map(&:chr).join
-    case string_encoding_mode
-    when StringEncodingMode::ASCII
-      raw_str.force_encoding("US-ASCII").encode("UTF-8")
-    when StringEncodingMode::UTF8
-      raw_str.force_encoding("UTF-8").encode("UTF-8")
-    when StringEncodingMode::UTF16
-      raw_str.force_encoding("UTF-16LE").encode("UTF-8")
-    when StringEncodingMode::UTF32
-      raw_str.force_encoding("UTF-32").encode("UTF-8")
-    else
-      raise "Argument out of range in deserialize_string"
-    end
-  end
-
-  def self.deserialize_int(encoded_int)
-    # Assuming a 32-bit little-endian integer.
-    value = 0
-    encoded_int.each_with_index do |byte, index|
-      value |= (byte & 0xFF) << (8 * index)
-    end
-    # Sign the extension if the 31st bit is set.
-    value -= (1 << 32) if (value & (1 << 31)) != 0
-    value
-  end
-
-  def self.deserialize_bool(encoded_bool)
-    encoded_bool[0] == 1
-  end
-
-  def self.deserialize_float(encoded_float)
-    # Reconstruct the 32-bit integer from the byte array.
-    bits = 0
-    encoded_float.each_with_index do |byte, index|
-      bits |= (byte & 0xFF) << (8 * index)
-    end
-
-    # IEEE 754 single precision (32-bit) decoding:
-    sign     = ((bits >> 31) == 0) ? 1 : -1
-    exponent = (bits >> 23) & 0xFF
-    fraction = bits & 0x7FFFFF
-
-    if exponent == 255
-      # Handle special cases for Inf and NaN.
-      return fraction == 0 ? sign * Float::INFINITY : Float::NAN
-    elsif exponent == 0
-      # Subnormal numbers.
-      return sign * (fraction.to_f / (1 << 23)) * (2 ** (-126))
-    else
-      # Normalized number.
-      return sign * (1 + fraction.to_f / (1 << 23)) * (2 ** (exponent - 127))
-    end
-  end
-
-  def self.deserialize_byte(encoded_byte)
-    encoded_byte[0]
-  end
-
-  def self.deserialize_char(encoded_char)
-    encoded_char[0].ord
-  end
-
-  def self.deserialize_longlong(encoded_long)
-    # Assuming a 64-bit little-endian integer.
-    value = 0
-    encoded_long.each_with_index do |byte, index|
-      value |= (byte & 0xFF) << (8 * index)
-    end
-    # Sign extension for 64-bit: if the 63rd bit is set.
-    value -= (1 << 64) if value >= (1 << 63)
-    value
-  end
-
-  def self.deserialize_double(encoded_double)
-    # Reconstruct the 64-bit bit pattern from the byte array.
-    bits = 0
-    encoded_double.each_with_index do |byte, index|
-      bits |= (byte & 0xFF) << (8 * index)
-    end
-
-    # IEEE 754 double precision (64-bit) decoding:
-    sign     = ((bits >> 63) == 0) ? 1 : -1
-    exponent = (bits >> 52) & 0x7FF
-    fraction = bits & 0xFFFFFFFFFFFFF
-
-    if exponent == 2047
-      return fraction == 0 ? sign * Float::INFINITY : Float::NAN
-    elsif exponent == 0
-      return sign * (fraction.to_f / (1 << 52)) * (2 ** (-1022))
-    else
-      return sign * (1 + fraction.to_f / (1 << 52)) * (2 ** (exponent - 1023))
-    end
-  end
-
-  def self.deserialize_ullong(encoded_ullong)
-    # Assuming an unsigned 64-bit little-endian integer.
-    value = 0
-    encoded_ullong.each_with_index do |byte, index|
-      value |= (byte & 0xFF) << (8 * index)
-    end
-    value
-  end
-
-  def self.deserialize_uint(encoded_uint)
-    # Assuming an unsigned 32-bit little-endian integer.
-    value = 0
-    encoded_uint.each_with_index do |byte, index|
-      value |= (byte & 0xFF) << (8 * index)
-    end
-    value
-  end
-
-  def self.deserialize_nil(encoded_nil)
-    nil
-  end
-
-end

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/protocol/type_serializer.rb

@@ -1,260 +0,0 @@
-require_relative '../../utils/type'
-require_relative '../../utils/string_encoding_mode'
-
-class TypeSerializer
-
-  def self.serialize_primitive(payload_item)
-    if payload_item.nil?
-      return serialize_nil
-    elsif [true, false].include? payload_item
-      return serialize_bool(payload_item)
-    elsif payload_item.is_a? Integer
-      if (-2 ** 31..2 ** 31 - 1).include?(payload_item)
-        return serialize_int(payload_item)
-      elsif (-2 ** 63..2 ** 63 - 1).include?(payload_item)
-        return serialize_longlong(payload_item)
-      else
-        return serialize_ullong(payload_item)
-      end
-    elsif payload_item.is_a? String
-      return serialize_string(payload_item)
-    elsif payload_item.is_a? Float
-      return serialize_double(payload_item)
-    elsif payload_item.is_a?(FalseClass) || payload_item.is_a?(TrueClass)
-      return 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)
-    return [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)
-    return [Type::JAVONET_STRING, StringEncodingMode::UTF8] + length + encoded_string_list
-  end
-
-  def self.serialize_int(int_value)
-    encoded_int_list = int_to_bytes(int_value)
-    length = encoded_int_list.length
-    return [Type::JAVONET_INTEGER, length] + encoded_int_list
-  end
-
-  def self.serialize_bool(bool_value)
-    encoded_bool_list = bool_value ? [1] : [0]
-    length = encoded_bool_list.length
-    return [Type::JAVONET_BOOLEAN, length] + encoded_bool_list
-  end
-
-  def self.serialize_float(float_value)
-    encoded_float_list = float_to_bytes(float_value)
-    length = encoded_float_list.length
-    return [Type::JAVONET_FLOAT, length] + encoded_float_list
-  end
-
-  def self.serialize_byte(byte_value)
-    encoded_byte_list = [byte_value & 0xFF]
-    length = encoded_byte_list.length
-    return [Type::JAVONET_BYTE, length] + encoded_byte_list
-  end
-
-  def self.serialize_char(char_value)
-    encoded_char_list = [char_value & 0xFF]
-    length = encoded_char_list.length
-    return [Type::JAVONET_CHAR, length] + encoded_char_list
-  end
-
-  def self.serialize_longlong(longlong_value)
-    encoded_longlong_list = longlong_to_bytes(longlong_value)
-    length = encoded_longlong_list.length
-    return [Type::JAVONET_LONG_LONG, length] + encoded_longlong_list
-  end
-
-  def self.serialize_double(double_value)
-    encoded_double_list = double_to_bytes(double_value)
-    length = encoded_double_list.length
-    return [Type::JAVONET_DOUBLE, length] + encoded_double_list
-  end
-
-  def self.serialize_uint(uint_value)
-    encoded_uint_list = uint_to_bytes(uint_value)
-    length = encoded_uint_list.length
-    return [Type::JAVONET_UNSIGNED_INTEGER, length] + encoded_uint_list
-  end
-
-  def self.serialize_ullong(ullong_value)
-    encoded_ullong_list = ullong_to_bytes(ullong_value)
-    length = encoded_ullong_list.length
-    return [Type::JAVONET_UNSIGNED_LONG_LONG, length] + encoded_ullong_list
-  end
-
-  def self.serialize_nil
-    return [Type::JAVONET_NULL, 1, 0]
-  end
-
-  # Helper methods for byte conversion
-  def self.int_to_bytes(value)
-    # Convert to 4-byte (32-bit) integer, little-endian
-    [
-      value & 0xFF,
-      (value >> 8) & 0xFF,
-      (value >> 16) & 0xFF,
-      (value >> 24) & 0xFF
-    ]
-  end
-
-  def self.uint_to_bytes(value)
-    # Convert to 4-byte unsigned integer, little-endian
-    [
-      value & 0xFF,
-      (value >> 8) & 0xFF,
-      (value >> 16) & 0xFF,
-      (value >> 24) & 0xFF
-    ]
-  end
-
-  def self.longlong_to_bytes(value)
-    # Convert to 8-byte (64-bit) integer, little-endian
-    [
-      value & 0xFF,
-      (value >> 8) & 0xFF,
-      (value >> 16) & 0xFF,
-      (value >> 24) & 0xFF,
-      (value >> 32) & 0xFF,
-      (value >> 40) & 0xFF,
-      (value >> 48) & 0xFF,
-      (value >> 56) & 0xFF
-    ]
-  end
-
-  def self.ullong_to_bytes(value)
-    # Convert to 8-byte unsigned long long, little-endian
-    [
-      value & 0xFF,
-      (value >> 8) & 0xFF,
-      (value >> 16) & 0xFF,
-      (value >> 24) & 0xFF,
-      (value >> 32) & 0xFF,
-      (value >> 40) & 0xFF,
-      (value >> 48) & 0xFF,
-      (value >> 56) & 0xFF
-    ]
-  end
-
-  def self.float_to_bytes(value)
-    # IEEE 754 single-precision binary floating-point format (32-bit)
-    # Manual implementation without using pack
-    bits = 0
-
-    if value == 0
-      # Zero is a special case
-      return [0, 0, 0, 0]
-    elsif value.nan?
-      # NaN is another special case
-      bits = 0x7FC00000
-    elsif value.infinite?
-      # Handle infinity
-      bits = value > 0 ? 0x7F800000 : 0xFF800000
-    else
-      # Regular number
-      sign = value < 0 ? 1 : 0
-      value = value.abs
-
-      # Get exponent and fraction
-      exponent = Math.log2(value).floor
-      fraction = value / (2.0**exponent) - 1.0
-
-      # Normalize exponent for IEEE 754 bias
-      biased_exponent = exponent + 127
-
-      # Clamp exponent to valid range
-      if biased_exponent <= 0
-        # Denormalized values
-        biased_exponent = 0
-        fraction = value / (2.0**(-126))
-      elsif biased_exponent >= 255
-        # Overflow, return infinity
-        biased_exponent = 255
-        fraction = 0
-      end
-
-      # Assemble the bits
-      fraction_bits = (fraction * 0x800000).round & 0x7FFFFF
-      bits = (sign << 31) | (biased_exponent << 23) | fraction_bits
-    end
-
-    # Convert to bytes (little-endian)
-    [
-      bits & 0xFF,
-      (bits >> 8) & 0xFF,
-      (bits >> 16) & 0xFF,
-      (bits >> 24) & 0xFF
-    ]
-  end
-
-  def self.double_to_bytes(value)
-    # IEEE 754 double-precision binary floating-point format (64-bit)
-    # Manual implementation without using pack
-    bits_low = 0
-    bits_high = 0
-
-    if value == 0
-      # Zero is a special case
-      return [0, 0, 0, 0, 0, 0, 0, 0]
-    elsif value.nan?
-      # NaN is another special case
-      bits_high = 0x7FF80000
-      bits_low = 0
-    elsif value.infinite?
-      # Handle infinity
-      bits_high = value > 0 ? 0x7FF00000 : 0xFFF00000
-      bits_low = 0
-    else
-      # Regular number
-      sign = value < 0 ? 1 : 0
-      value = value.abs
-
-      # Get exponent and fraction
-      exponent = Math.log2(value).floor
-      fraction = value / (2.0**exponent) - 1.0
-
-      # Normalize exponent for IEEE 754 bias
-      biased_exponent = exponent + 1023
-
-      # Clamp exponent to valid range
-      if biased_exponent <= 0
-        # Denormalized values
-        biased_exponent = 0
-        fraction = value / (2.0**(-1022))
-      elsif biased_exponent >= 2047
-        # Overflow, return infinity
-        biased_exponent = 2047
-        fraction = 0
-      end
-
-      # Assemble the bits
-      # Convert a fraction to 52-bit integer
-      fraction_bits = (fraction * 0x10000000000000).round
-
-      # Split into high and low 32-bit words
-      bits_high = (sign << 31) | (biased_exponent << 20) | ((fraction_bits >> 32) & 0xFFFFF)
-      bits_low = fraction_bits & 0xFFFFFFFF
-    end
-
-    # Convert to bytes (little-endian)
-    [
-      bits_low & 0xFF,
-      (bits_low >> 8) & 0xFF,
-      (bits_low >> 16) & 0xFF,
-      (bits_low >> 24) & 0xFF,
-      bits_high & 0xFF,
-      (bits_high >> 8) & 0xFF,
-      (bits_high >> 16) & 0xFF,
-      (bits_high >> 24) & 0xFF
-    ]
-  end
-end

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/receiver/receiver.rb

@@ -1,39 +0,0 @@
-require_relative '../interpreter/interpreter'
-require_relative '../../utils/runtime_logger'
-require_relative '../protocol/command_serializer'
-require_relative '../../utils/command'
-
-class Receiver
-
-  def initialize
-    puts get_runtime_info
-  end
-
-  def send_command(message_array, message_array_len)
-    begin
-      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(RuntimeName::RUBY, CommandType::EXCEPTION, [])
-      exception_command = exception_command.add_arg_to_payload(ExceptionType::EXCEPTION)
-      exception_command = exception_command.add_arg_to_payload(Command.new(RuntimeName::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__)
-      CommandSerializer.new.serialize(exception_command)
-    end
-  end
-
-  def heart_beat(message_array, message_array_len)
-    [49,48]
-  end
-
-  def get_runtime_info
-    RuntimeLogger.get_runtime_info(true)
-  end
-end
-

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/reference_cache/references_cache.rb

@@ -1,39 +0,0 @@
-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/Binaries/Ruby/MacOs/X64/core/transmitter/transmitter.rb

@@ -1,58 +0,0 @@
-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/Binaries/Ruby/MacOs/X64/core/transmitter/transmitter_wrapper.rb

@@ -1,32 +0,0 @@
-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/Binaries/Ruby/MacOs/X64/core/type_cache/type_cache.rb

@@ -1,42 +0,0 @@
-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

data/lib/javonet-ruby-sdk/Binaries/Ruby/MacOs/X64/core/web_socket_client/web_socket_client.rb

@@ -1,108 +0,0 @@
-require 'websocket'
-require 'uri'
-
-class WebSocketClient
-  def initialize(url)
-    @uri = URI.parse(url)
-    raise "Only ws:// or wss:// URLs are supported" unless %w[ws wss].include?(@uri.scheme)
-
-    @host = @uri.host
-    @port = @uri.port || default_port
-    @path = @uri.path.empty? ? '/' : @uri.path
-    @path += "?#{@uri.query}" if @uri.query
-
-    @socket = open_socket
-    @handshake = WebSocket::Handshake::Client.new(
-      url: url
-    )
-
-    perform_handshake
-  end
-
-  def send_message(message)
-    frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, data: message.pack("C*"), type: :binary)
-    @socket.write(frame.to_s)
-  end
-
-  def receive_message(timeout: 5)
-    buffer = ''
-    start_time = Time.now
-
-    while Time.now - start_time < timeout
-      if IO.select([@socket], nil, nil, 0.1)
-        chunk = @socket.read_nonblock(1024, exception: false)
-        break if chunk.nil?
-
-        buffer << chunk
-        frame = WebSocket::Frame::Incoming::Client.new(version: @handshake.version)
-        frame << buffer
-        data = frame.next
-        return data.data.bytes if data
-      end
-    end
-
-    nil
-  end
-
-  def self.add_or_get_client(url)
-    @@clients ||= {}
-    client = @@clients[url]
-    if client.nil? || !client.open?
-      client&.close
-      client = new(url)
-      @@clients[url] = client
-    end
-    client
-  end
-
-  def self.send_message(url, message)
-    client = add_or_get_client(url)
-    client.send_message(message)
-    client.receive_message
-  end
-
-  def open?
-    !@socket.closed?
-  end
-
-  def close
-    frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, type: :close)
-    @socket.write(frame.to_s)
-    @socket.close
-  end
-
-  private
-
-  def default_port
-    @uri.scheme == 'wss' ? 443 : 80
-  end
-
-  def open_socket
-    tcp = TCPSocket.new(@host, @port)
-
-    if @uri.scheme == 'wss'
-      ssl_context = OpenSSL::SSL::SSLContext.new
-      ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      ssl = OpenSSL::SSL::SSLSocket.new(tcp, ssl_context)
-      ssl.sync_close = true
-      ssl.hostname = @host
-      ssl.connect
-      ssl
-    else
-      tcp
-    end
-  end
-
-  def perform_handshake
-    @socket.write(@handshake.to_s)
-
-    until @handshake.finished?
-      line = @socket.gets
-      break if line.nil?
-
-      @handshake << line
-    end
-
-    raise "WebSocket handshake failed!" unless @handshake.valid?
-  end
-end