javonet-ruby-sdk 2.6.0 → 2.6.2

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

@@ -1,105 +0,0 @@
-require_relative '../../utils/runtime_name'
-require_relative '../../utils/command_type'
-require_relative '../../utils/command'
-require_relative '../../core/handler/handler_dictionary'
-require_relative '../../core/handler/abstract_handler'
-require_relative '../../core/handler/value_handler'
-require_relative '../../core/handler/load_library_handler'
-require_relative '../../core/handler/invoke_static_method_handler'
-require_relative '../../core/handler/get_static_field_handler'
-require_relative '../../core/handler/get_instance_field_handler'
-require_relative '../../core/handler/set_instance_field_handler'
-require_relative '../../core/handler/create_class_instance_handler'
-require_relative '../../core/handler/set_static_field_handler'
-require_relative '../../core/handler/get_type_handler'
-require_relative '../../core/handler/invoke_instance_method_handler'
-require_relative '../../core/handler/resolve_instance_handler'
-require_relative '../../core/handler/casting_handler'
-require_relative '../../core/handler/destruct_reference_handler'
-require_relative '../../core/handler/array_get_item_handler'
-require_relative '../../core/handler/array_get_size_handler'
-require_relative '../../core/handler/array_get_rank_handler'
-require_relative '../../core/handler/array_set_item_handler'
-require_relative '../../core/handler/array_handler'
-require_relative '../../core/handler/enable_namespace_handler'
-require_relative '../../core/handler/enable_type_handler'
-require_relative '../../core/handler/invoke_global_function_handler'
-require_relative '../../core/reference_cache/references_cache'
-require_relative '../../utils/exceptions/exception_serializer'
-require_relative '../../utils/types_handler'
-
-
-class Handler < AbstractHandler
-
-  def initialize
-    super
-    value_handler = ValueHandler.new
-    load_library_handler = LoadLibraryHandler.new
-    invoke_static_method_handler = InvokeStaticMethodHandler.new
-    get_static_field_handler = GetStaticFieldHandler.new
-    get_class_instance_handler = CreateClassInstanceHandler.new
-    set_static_field_handler = SetStaticFieldHandler.new
-    get_type_handler = GetTypeHandler.new
-    invoke_instance_method_handler = InvokeInstanceMethodHandler.new
-    resolve_instance_handler = ResolveInstanceHandler.new
-    casting_handler = CastingHandler.new
-    get_instance_field_handler = GetInstanceFieldHandler.new
-    set_instance_field_handler = SetInstanceFieldHandler.new
-    destruct_reference_handler = DestructReferenceHandler.new
-    array_get_item_handler = ArrayGetItemHandler.new
-    array_get_size_handler = ArrayGetSizeHandler.new
-    array_get_rank_handler = ArrayGetRankHandler.new
-    array_set_item_handler = ArraySetItemHandler.new
-    array_handler = ArrayHandler.new
-    enable_namespace_handler = EnableNamespaceHandler.new
-    enable_type_handler = EnableTypeHandler.new
-    invoke_global_function_handler = InvokeGlobalFunctionHandler.new
-
-
-    $handler_dict[CommandType::VALUE] = value_handler
-    $handler_dict[CommandType::LOAD_LIBRARY] = load_library_handler
-    $handler_dict[CommandType::INVOKE_STATIC_METHOD] = invoke_static_method_handler
-    $handler_dict[CommandType::GET_STATIC_FIELD] = get_static_field_handler
-    $handler_dict[CommandType::CREATE_CLASS_INSTANCE] = get_class_instance_handler
-    $handler_dict[CommandType::SET_STATIC_FIELD] = set_static_field_handler
-    $handler_dict[CommandType::GET_TYPE] = get_type_handler
-    $handler_dict[CommandType::INVOKE_INSTANCE_METHOD] = invoke_instance_method_handler
-    $handler_dict[CommandType::REFERENCE] = resolve_instance_handler
-    $handler_dict[CommandType::CAST] = casting_handler
-    $handler_dict[CommandType::GET_INSTANCE_FIELD] = get_instance_field_handler
-    $handler_dict[CommandType::SET_INSTANCE_FIELD] = set_instance_field_handler
-    $handler_dict[CommandType::DESTRUCT_REFERENCE] = destruct_reference_handler
-    $handler_dict[CommandType::ARRAY_GET_ITEM] = array_get_item_handler
-    $handler_dict[CommandType::ARRAY_GET_SIZE] = array_get_size_handler
-    $handler_dict[CommandType::ARRAY_GET_RANK] = array_get_rank_handler
-    $handler_dict[CommandType::ARRAY_SET_ITEM] = array_set_item_handler
-    $handler_dict[CommandType::ARRAY] = array_handler
-    $handler_dict[CommandType::ENABLE_NAMESPACE] = enable_namespace_handler
-    $handler_dict[CommandType::ENABLE_TYPE] = enable_type_handler
-    $handler_dict[CommandType::INVOKE_GLOBAL_FUNCTION] = invoke_global_function_handler
-  end
-
-
-  def handle_command(command)
-    if command.command_type == CommandType::RETRIEVE_ARRAY
-      response_array = $handler_dict[CommandType::REFERENCE].handle_command(command.payload[0])
-      return Command.create_array_response(response_array, command.runtime_name)
-    end
-    response = $handler_dict[command.command_type].handle_command(command)
-      if TypesHandler.primitive_or_none?(response)
-        Command.create_response(response, command.runtime_name)
-      elsif response.is_a? Exception
-        ExceptionSerializer.serialize_exception(response, command)
-      else
-        reference_cache = ReferencesCache.instance
-        guid = reference_cache.cache_reference(response)
-        Command.create_reference(guid, command.runtime_name)
-      end
-  end
-
-  def is_response_array(response)
-    response.is_a? Array
-  end
-
-
-end

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

@@ -1,8 +0,0 @@
-$handler_dict = Hash.new
-
-class HandlerDictionary
-
-  def self.add_handler_to_dict(command_type, handler)
-    $handler_dict[command_type] = handler
-  end
-end

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

@@ -1,45 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class InvokeGlobalFunctionHandler < AbstractCommandHandler
-  def process(command)
-    invoke_function(command)
-  end
-
-  def invoke_function(command)
-    begin
-      payload = command.payload
-      raise ArgumentError, "InvokeGlobalFunction requires at least one parameter" if payload.empty?
-
-      # Expect the first parameter to be a string in the form "ModuleName.function_name"
-      full_method_string = payload[0]
-      unless full_method_string.is_a?(String) && full_method_string.include?(".")
-        raise ArgumentError, "Expected a string in the format 'ModuleName.function_name'"
-      end
-
-      parts = full_method_string.split(".")
-      if parts.size < 2
-        raise ArgumentError, "Invalid function identifier format. Expected 'ModuleName.function_name'"
-      end
-
-      function_name = parts.pop
-      module_name = parts.join("::") # Convert dot-separated names to Ruby's "::" notation
-
-      begin
-        target = Object.const_get(module_name)
-      rescue NameError => e
-        raise NameError, "Module/Class #{module_name} not found: #{e.message}"
-      end
-
-      args = payload[1..-1] || []
-
-      if target.respond_to?(function_name)
-        target.send(function_name, *args)
-      else
-        available_methods = target.methods.join(', ')
-        raise NoMethodError, "Method #{function_name} not found in module #{module_name}. Available methods: #{available_methods}"
-      end
-    rescue Exception => e
-      e
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class InvokeInstanceMethodHandler < AbstractCommandHandler
-  def initialize
-    @required_parameters_count = 2
-  end
-
-  def process(command)
-    invoke_instance_method(command)
-  end
-
-  def invoke_instance_method(command)
-    begin
-      if command.payload.length < @required_parameters_count
-        raise ArgumentError.new "InvokeInstanceMethod parameters mismatch"
-      end
-
-      instance = command.payload[0]
-      method_name = command.payload[1]
-
-      if command.payload.length > 2
-        arguments = command.payload[2..]
-        return instance.send(method_name, *arguments)
-      else
-        return instance.send(method_name)
-      end
-    rescue NoMethodError
-      methods = instance.methods
-      message = "Method #{method_name} not found in object of class #{instance.class.name}. Available methods:\n"
-      methods.each { |method_iter| message += "#{method_iter}\n" }
-      raise Exception, message
-    rescue Exception => e
-      return e
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class InvokeStaticMethodHandler < AbstractCommandHandler
-  def initialize
-    @required_parameters_count = 2
-  end
-
-  def process(command)
-    invoke_static_method(command)
-  end
-
-  def invoke_static_method(command)
-    begin
-      if command.payload.length < @required_parameters_count
-        raise ArgumentError.new "Static method parameters mismatch"
-      end
-
-      type = command.payload[0]
-      method_name = command.payload[1]
-      begin
-        if command.payload.length > @required_parameters_count
-          args = command.payload[2..]
-          result = type.send(method_name, *args)
-        else
-          result = type.send(method_name)
-        end
-        return result
-      rescue NoMethodError
-        methods = command.payload[0].methods
-        message = "Method #{method_name} not found in class #{command.payload[0].name}. Available methods:\n"
-        methods.each { |method_iter| message += "#{method_iter}\n" }
-        raise Exception, message
-      end
-    rescue Exception => e
-      return e
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class LoadLibraryHandler < AbstractCommandHandler
-
-  @@loaded_libraries = []
-
-  def initialize
-    @required_parameters_count = 1
-  end
-
-  def process(command)
-    begin
-      if command.payload.length < @required_parameters_count
-        raise ArgumentError.new "Load library parameters mismatch"
-      end
-      if command.payload.length > @required_parameters_count
-        assembly_name = command.payload[1]
-      else
-        assembly_name = command.payload[0]
-      end
-      
-      # Check if the library exists:
-      raise LoadError.new("Library not found: #{assembly_name}") unless File.exist?(assembly_name)
-      #noinspection RubyResolve
-      require(assembly_name)
-      @@loaded_libraries.push(assembly_name)
-      return 0
-    rescue Exception => e
-      return e
-    end
-  end
-
-  def self.get_loaded_libraries
-    @@loaded_libraries
-  end
-end

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

@@ -1,29 +0,0 @@
-require_relative '../reference_cache/references_cache'
-require_relative 'abstract_command_handler'
-require_relative '../../utils/runtime_name'
-require_relative '../../utils/command'
-
-class ResolveInstanceHandler < AbstractCommandHandler
-  def initialize
-    @required_parameters_count = 1
-  end
-
-  def process(command)
-    resolve_reference(command)
-  end
-
-  def resolve_reference(command)
-    if command.payload.length != @required_parameters_count
-      raise ArgumentError.new "Resolve Instance parameters mismatch"
-    end
-    begin
-      if command.runtime_name == RuntimeName::RUBY
-        return ReferencesCache.instance.resolve_reference(command.payload[0])
-      else
-        return new Command(command.runtime_name, CommandType::REFERENCE, command.payload[0])
-      end
-    rescue Exception => ex
-      return ex
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class SetInstanceFieldHandler < AbstractCommandHandler
-  def initialize
-    @required_parameters_count = 3
-  end
-
-  def process(command)
-    return set_instance_field(command)
-  end
-
-  def set_instance_field(command)
-    begin
-      if command.payload.length < @required_parameters_count
-        raise ArgumentError.new "Set Instance Field parameters mismatch"
-      end
-  
-      merged_value = '@' + command.payload[1]
-      begin
-        if command.payload[0].instance_variable_defined?(merged_value)
-          command.payload[0].instance_variable_set(merged_value, command.payload[2])
-        else
-          raise Exception
-        end
-      rescue Exception
-        fields = command.payload[0].instance_variables
-        message = "Field #{command.payload[1]} not found in class #{command.payload[0].class.name}. Available fields:\n"
-        fields.each { |field_iter| message += "#{field_iter} \n" }
-        raise ArgumentError, message
-      end
-    rescue Exception => e
-      return e
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class SetStaticFieldHandler < AbstractCommandHandler
-  def initialize
-    @required_parameters_count = 3
-  end
-
-  def process(command)
-    Command.new(RuntimeName::RUBY, CommandType::VALUE, [set_static_field(command)])
-  end
-
-  def set_static_field(command)
-    begin
-      if command.payload.length != @required_parameters_count
-        raise ArgumentError.new "Set static field parameters mismatch"
-      end
-
-      merged_value = '@@' + command.payload[1]
-      begin
-        command.payload[0].class_variable_set(merged_value, command.payload[2])
-      rescue Exception
-        fields = command.payload[0].class_variables
-        message = "Field #{command.payload[1]} not found in class #{command.payload[0].name}. Available fields:\n"
-        fields.each { |field_iter| message += "#{field_iter}\n" }
-        raise ArgumentError, message
-      end
-    rescue Exception => e
-      return e
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-require_relative 'abstract_command_handler'
-
-class ValueHandler < AbstractCommandHandler
-  def process(command)
-    command.payload[0]
-  end
-end

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

@@ -1,28 +0,0 @@
-require_relative '../protocol/command_serializer'
-require_relative '../protocol/command_deserializer'
-require_relative '../handler/handler'
-
-class Interpreter
-  @@handler = Handler.new
-
-  def execute(command, connection_type, connection_data)
-    message_byte_array = CommandSerializer.new.serialize(command, connection_data)
-    if command.runtime_name == RuntimeName::RUBY && connection_type == ConnectionType::IN_MEMORY
-      require_relative '../receiver/receiver'
-      response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
-    elsif connection_type == ConnectionType::WEB_SOCKET
-      require_relative '../web_socket_client/web_socket_client'
-      response_byte_array = WebSocketClient.send_message(connection_data.hostname, message_byte_array)
-    else
-      require_relative '../transmitter/transmitter'
-      response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)
-    end
-
-    CommandDeserializer.new(response_byte_array).deserialize
-  end
-
-  def process(byte_array)
-    received_command = CommandDeserializer.new(byte_array).deserialize
-    @@handler.handle_command(received_command)
-  end
-end

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

@@ -1,42 +0,0 @@
-class NamespaceCache
-  attr_accessor :namespace_cache
-
-  def self.instance
-    @instance ||= new
-  end
-
-  private_class_method :new
-
-  def initialize
-    @namespace_cache = []
-  end
-
-  def cache_namespace(namespace_regex)
-    @namespace_cache << namespace_regex
-  end
-
-  def is_namespace_cache_empty?
-    @namespace_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}"
-                    end
-
-    @namespace_cache.any? do |pattern|
-      /#{pattern}/.match?(name_to_check)
-    end
-  end
-
-  def get_cached_namespaces
-    @namespace_cache
-  end
-
-  def clear_cache
-    @namespace_cache.clear
-    0
-  end
-end

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

@@ -1,182 +0,0 @@
-require_relative 'type_deserializer'
-require_relative '../../utils/type'
-require_relative '../../utils/command'
-require_relative '../../utils/string_encoding_mode'
-require_relative '../../utils/command_type'
-require_relative '../../utils/runtime_name'
-
-class CommandDeserializer
-  def initialize(buffer)
-    @buffer = buffer
-    @buffer_len = buffer.length
-    @command = Command.new(buffer[0], buffer[10], [])
-    @position = 11
-  end
-
-  def is_at_end
-    @position == @buffer_len
-  end
-
-  def deserialize
-    until is_at_end
-      @command = @command.add_arg_to_payload(read_object(@buffer[@position]))
-    end
-    @command
-  end
-
-  def read_object(type_num)
-    case type_num
-    when Type::COMMAND
-      return self.read_command
-    when Type::JAVONET_STRING
-      return self.read_string
-    when Type::JAVONET_INTEGER
-      return self.read_int
-    when Type::JAVONET_BOOLEAN
-      return self.read_bool
-    when Type::JAVONET_FLOAT
-      return self.read_float
-    when Type::JAVONET_BYTE
-      return self.read_byte
-    when Type::JAVONET_CHAR
-      return self.read_char
-    when Type::JAVONET_LONG_LONG
-      return self.read_longlong
-    when Type::JAVONET_DOUBLE
-      return self.read_double
-    when Type::JAVONET_UNSIGNED_LONG_LONG
-      return self.read_ullong
-    when Type::JAVONET_UNSIGNED_INTEGER
-      return self.read_uint
-    when Type::JAVONET_NULL
-      return self.read_nil
-    else
-      raise Exception.new("Type #{type_num} not supported in command deserializer")
-    end
-  end
-
-  def read_command
-    p = @position
-    number_of_elements_in_payload = TypeDeserializer.deserialize_int(@buffer[p + 1..p + 4])
-    runtime = @buffer[p + 5]
-    command_type = @buffer[p + 6]
-    @position += 7
-
-    payload = Array.new(number_of_elements_in_payload)
-    for i in 0..number_of_elements_in_payload - 1
-      payload[i] = read_object(@buffer[@position])
-    end
-    Command.new(runtime, command_type, payload)
-  end
-
-  # old implementation
-  #  def read_command
-  #    p = @position
-  #    number_of_elements_in_payload = TypeDeserializer.deserialize_int(@buffer[p + 1..p + 4])
-  #    runtime = @buffer[p + 5]
-  #    command_type = @buffer[p + 6]
-  #    @position += 7
-  #    return_command = Command.new(runtime, command_type, [])
-  #    read_command_recursively(number_of_elements_in_payload, return_command)
-  #  end
-  #
-  #  def read_command_recursively(number_of_elements_in_payload_left, cmd)
-  #    if number_of_elements_in_payload_left == 0
-  #      cmd
-  #    else
-  #      p = @position
-  #      cmd = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
-  #      read_command_recursively(number_of_elements_in_payload_left - 1, cmd)
-  #    end
-  #  end
-
-  def read_string
-    p = @position
-    string_encoding_mode = @buffer[p + 1]
-    size = TypeDeserializer.deserialize_int(@buffer[p + 2..p + 5])
-    @position += 6
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_string(string_encoding_mode, @buffer[p...p + size])
-  end
-
-  def read_int
-    size = 4
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_int(@buffer[p...p + size])
-  end
-
-  def read_bool
-    size = 1
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_bool(@buffer[p...p + size])
-  end
-
-  def read_float
-    size = 4
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_float(@buffer[p...p + size])
-  end
-
-  def read_byte
-    size = 1
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_byte(@buffer[p...p + size])
-  end
-
-  def read_char
-    size = 1
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_char(@buffer[p...p + size])
-  end
-
-  def read_longlong
-    size = 8
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_longlong(@buffer[p...p + size])
-  end
-
-  def read_double
-    size = 8
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_double(@buffer[p...p + size])
-  end
-
-  def read_ullong
-    size = 8
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_ullong(@buffer[p...p + size])
-  end
-
-  def read_uint
-    size = 4
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_uint(@buffer[p...p + size])
-  end
-
-  def read_nil
-    size = 1
-    @position += 2
-    p = @position
-    @position += size
-    TypeDeserializer.deserialize_nil(@buffer[p...p + size])
-  end
-end

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

@@ -1,39 +0,0 @@
-require_relative 'type_serializer'
-require_relative '../../utils/command'
-require_relative '../../utils/runtime_name'
-require_relative '../../utils/tcp_connection_data'
-
-class CommandSerializer
-  def serialize(root_command, connection_data = nil, runtime_version = 0)
-    buffer = []
-    buffer << root_command.runtime_name
-    buffer << runtime_version
-
-    if connection_data
-      buffer.concat(connection_data.serialize_connection_data)
-    else
-      buffer.concat([0, 0, 0, 0, 0, 0, 0])
-    end
-
-    buffer << RuntimeName::RUBY
-    buffer << root_command.command_type
-
-    serialize_recursively(root_command, buffer)
-    buffer
-  end
-
-  def serialize_recursively(command, buffer)
-    command.payload.each do |item|
-      if item.is_a?(Command)
-        buffer.concat(TypeSerializer.serialize_command(item))
-        serialize_recursively(item, buffer)
-      elsif TypesHandler.primitive_or_none?(item)
-        buffer.concat(TypeSerializer.serialize_primitive(item))
-      else
-        cached_reference = ReferencesCache.new.cache_reference(item)
-        ref_command = Command.new(RuntimeName::RUBY, CommandType::REFERENCE, cached_reference)
-        serialize_recursively(ref_command, buffer)
-      end
-    end
-  end
-end