krpc 0.4.0.beta2 → 0.4.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e7d575d4a1dbb6498787b0e82a39730f94f0d0d
-  data.tar.gz: 79568d6c4d305a5921ebc5c4c646825ccf484f73
+  metadata.gz: 34cd7307210203562c7780105ae99214371fea14
+  data.tar.gz: 4088ab02a044dd1bef3b60ae94df0d60ec877bab
 SHA512:
-  metadata.gz: c23caec29dd780b472326b178f914db6b9b6751c7e109d05df181c9cb3a45bc55cbecf2f0fff2f624f4ad7e2e67740285307ea000a3b3a76db574453a7463ac0
-  data.tar.gz: 9b6725253fe71724ed3ceb2b22280a46bda329a339fb2d05b8bcda88f2fd6e5515883cd030547e8d326b3d8d3b06eb986cef375895a26a33b8f99eb17fcc4531
+  metadata.gz: 417a3bddec8125acbf6062fc3e2eaf520bc5edec63cc7738d984d658f631717eede00e3566f5880968e7019a0129912764c41d45cce1d8d7990ab53e28c9cd6f
+  data.tar.gz: a0dce5abd9b4729299ab70d5c4316408f68c95e8ad02722ca5d993e3221fa0e0abab5aeb66e6cf3efc48730a82b3c8d591e196bd6fd86179c638d8c94e1eac1d

data/README.md

@@ -94,7 +94,7 @@ SpaceCenter.transform_position(
 	to :ReferenceFrame - The reference frame to covert the position vector to.
 ) :Array[Float, Float, Float] - The corresponding position vector in reference frame to.
 
- Converts a position vector from one reference frame to another. 
+ Converts a position vector from one reference frame to another.
 => nil
 ```
 

data/krpc.gemspec

@@ -24,12 +24,12 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = ">= 2.1.0"
 
-  s.add_runtime_dependency "google-protobuf", "~> 3.1"
+  s.add_runtime_dependency "google-protobuf", "~> 3.4"
   s.add_runtime_dependency "colorize", "~> 0.8"
-  s.add_runtime_dependency "nokogiri", "~> 1.6"
-  s.add_development_dependency "bundler", "~> 1.13"
-  s.add_development_dependency "pry", "~> 0.10"
-  s.add_development_dependency "rspec", "~> 3.5"
-  s.add_development_dependency "rake", "~> 11.3"
+  s.add_runtime_dependency "nokogiri", "~> 1.8"
+  s.add_development_dependency "bundler", "~> 1.15"
+  s.add_development_dependency "pry", "~> 0.11"
+  s.add_development_dependency "rspec", "~> 3.6"
+  s.add_development_dependency "rake", "~> 12.1"
   s.add_development_dependency "hanna-nouveau", "~> 1.0"
 end

data/lib/krpc.rb

@@ -4,13 +4,13 @@ require 'krpc/client'
 
 module KRPC
   class << self
-  
+
     # Connect to a kRPC server, generate services API and return Client object. If the block is
     # given, then it's called passing Client object and the connection to kRPC server is closed
     # at the end of the block.
     def connect(*args, &block)
       Client.new(*args).connect!(&block)
     end
-    
+
   end
 end

data/lib/krpc/client.rb

@@ -9,11 +9,11 @@ require 'krpc/core_extensions'
 require 'krpc/krpc.pb'
 
 module KRPC
-  
+
   ##
-  # A kRPC client, through which all Remote Procedure Calls are made. To make RPC calls client 
+  # A kRPC client, through which all Remote Procedure Calls are made. To make RPC calls client
   # must first connect to server. This can be achieved by calling Client#connect or Client#connect!
-  # methods. Client object can connect and disconnect from the server many times during it's 
+  # methods. Client object can connect and disconnect from the server many times during it's
   # lifetime. RPCs can be made by calling Client#execute_rpc method. After generating the services API
   # (with Client#generate_services_api! call), RPCs can be also made using
   # `client.service_name.procedure_name(parameter, ...)`
@@ -34,7 +34,7 @@ module KRPC
 
     attr_reader :name, :rpc_connection, :stream_connection, :streams_manager, :core
 
-    # Create new Client object, optionally specifying IP address and port numbers on witch kRPC 
+    # Create new Client object, optionally specifying IP address and port numbers on witch kRPC
     # server is listening and the name for this client.
     def initialize(name: DEFAULT_NAME, host: Connection::DEFAULT_SERVER_HOST, rpc_port: Connection::DEFAULT_SERVER_RPC_PORT, stream_port: Connection::DEFAULT_SERVER_STREAM_PORT)
       @name = name
@@ -45,10 +45,10 @@ module KRPC
       @core = Services::Core.new(self)
       Doc.add_docstring_info(false, self.class, "core", return_type: @core.class, xmldoc: "<doc><summary>Core kRPC service, e.g. for querying for the available services. Most of this functionality is used internally by the Ruby client and therefore does not need to be used directly from application code. This service is hardcoded (in kRPC Ruby client) version of 'krpc' service, so 1) it is available even before the services API is generated, but 2) can be out of sync with 'krpc' service.</summary></doc>")
     end
-    
+
     # Connect to a kRPC server on the IP address and port numbers specified during this client
     # object creation and return `self`. Calling this method while the client is already connected
-    # will raise an exception. If the block is given, then it's called passing `self` and the 
+    # will raise an exception. If the block is given, then it's called passing `self` and the
     # connection to kRPC server is closed at the end of the block.
     def connect(&block)
       rpc_connection.connect
@@ -57,9 +57,9 @@ module KRPC
       call_block_and_close(block) if block_given?
       self
     end
-    
+
     # Connect to a kRPC server, generate the services API and return `self`. Shorthand for calling
-    # Client#connect and Client#generate_services_api! subsequently. If the block is given, then 
+    # Client#connect and Client#generate_services_api! subsequently. If the block is given, then
     # it's called passing `self` and the connection to kRPC server is closed at the end of the block.
     def connect!(&block)
       connect
@@ -67,8 +67,8 @@ module KRPC
       call_block_and_close(block) if block_given?
       self
     end
-    
-    # Close connection to kRPC server. Returns `true` if the connection has closed or `false` if 
+
+    # Close connection to kRPC server. Returns `true` if the connection has closed or `false` if
     # the client had been already disconnected.
     def close
       streams_manager.remove_all_streams
@@ -81,16 +81,16 @@ module KRPC
     def connected?
       rpc_connection.connected?
     end
-      
-    # Interrogates the server to find out what functionality it provides and dynamically creates 
+
+    # Interrogates the server to find out what functionality it provides and dynamically creates
     # all of the classes and methods that form the services API. For each service that server provides:
-    # 
+    #
     # 1. Class `KRPC::Services::{service name here}`, and module `KRPC::Gen::{service name here}`
     #    are created.
     # 2. `KRPC::Gen::{service name here}` module is filled with dynamically created classes.
     # 3. Those classes in turn are filled with dynamically created methods, which form the API for
     #    this service.
-    # 4. Instance method `{service name here}` is created in this client object that returns 
+    # 4. Instance method `{service name here}` is created in this client object that returns
     #    `KRPC::Services::{service name here}` object. This object is entry point for accessing
     #    functionality provided by `{service name here}` service.
     #
@@ -108,7 +108,7 @@ module KRPC
     def generate_services_api!
       return self if services_api_generated?
       raise(Error, "Can't generate the services API while not connected to a server -- call Client#connect! to connect to server and generate the services API in one call") if not connected?
-      
+
       resp = core.get_services
       resp.services.each do |service_msg|
         service_class = Services.create_service(service_msg)
@@ -122,17 +122,17 @@ module KRPC
       end
       self
     end
-    
+
     # Returns `true` if the services API has been already generated, `false` otherwise.
     def services_api_generated?
       respond_to? :space_center or respond_to? :test_service
     end
-    
+
     # Execute an RPC.
     def execute_rpc(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[], return_type: nil)
       send_request(service, procedure, args, kwargs, param_names, param_types, param_default)
       result = receive_result
-      raise(RPCError, result.error) unless result.field_empty? :error
+      raise build_exception(result.error) unless result.field_empty? :error
       unless return_type.nil?
         Decoder.decode(result.value, return_type, self)
       else
@@ -143,13 +143,13 @@ module KRPC
       raise e
     end
 
-    # Build a PB::Request object.
+    # Build an PB::Request object.
     def build_request(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[])
       call = build_procedure_call(service, procedure, args, kwargs, param_names, param_types, param_default)
       PB::Request.new(calls: [call])
     end
 
-    # Build a PB::ProcedureCall object.
+    # Build an PB::ProcedureCall object.
     def build_procedure_call(service, procedure, args=[], kwargs={}, param_names=[], param_types=[], param_default=[])
       begin
         raise(ArgumentError, "param_names and param_types should be equal length\n\tparam_names = #{param_names}\n\tparam_types = #{param_types}") unless param_names.length == param_types.length
@@ -163,12 +163,20 @@ module KRPC
       PB::ProcedureCall.new(service: service, procedure: procedure, arguments: call_args)
     end
 
+    # Build an exception from an PB::Error object.
+    def build_exception(error)
+      msg = error.description
+      msg = "#{error.service}.#{error.name}: #{msg}" unless error.field_empty?(:service) || error.field_empty?(:name)
+      msg += "\nServer stack trace:\n#{error.stack_trace}" unless error.field_empty?(:stack_trace)
+      RPCError.new(msg)
+    end
+
     protected #----------------------------------
-    
+
     def construct_arguments(args, kwargs, param_names, param_types, param_default, required_params_count)
       param_names_symbols = param_names.map(&:to_sym)
       kwargs_remaining = kwargs.count
-      
+
       call_args = param_names_symbols.map.with_index do |name, i|
         is_kwarg = kwargs.has_key? name
         kwargs_remaining -= 1 if is_kwarg
@@ -194,7 +202,7 @@ module KRPC
           PB::Argument.new(position: i, value: v)
         end
       end.compact
-      
+
       raise ArgumentErrorSig.new("keyword arguments for non existing parameters: #{(kwargs.keys - param_names_symbols).join(", ")}") unless kwargs_remaining == 0
       call_args
     end
@@ -203,16 +211,16 @@ module KRPC
       req = build_request(service, procedure, args, kwargs, param_names, param_types, param_default)
       rpc_connection.send_message req
     end
-    
+
     def receive_result
       resp = rpc_connection.receive_message PB::Response
-      raise(RPCError, resp.error) unless resp.field_empty? :error
+      raise build_exception(resp.error) unless resp.field_empty? :error
       resp.results[0]
     end
-    
+
     def call_block_and_close(block)
       begin block.call(self) ensure close end
     end
-    
+
   end
 end

data/lib/krpc/connection.rb

@@ -10,18 +10,18 @@ module KRPC
     DEFAULT_SERVER_HOST = "127.0.0.1"
     DEFAULT_SERVER_RPC_PORT = 50000
     DEFAULT_SERVER_STREAM_PORT = 50001
-    
+
     attr_reader :host, :port, :socket
-    
+
     def initialize(host, port)
       @host, @port = host, port
     end
-    
+
     # Connect and perform handshake.
     def connect
       if connected? then raise(ConnectionError, "Already connected")
-      else 
-        @socket = TCPSocket.open(host, port) 
+      else
+        @socket = TCPSocket.open(host, port)
         begin
           handshake
         rescue Exception => e
@@ -31,7 +31,7 @@ module KRPC
       end
       self
     end
-    
+
     # Close connection and clean up.
     def close
       if connected?
@@ -40,29 +40,29 @@ module KRPC
         true
       else false end
     end
-    
+
     # Return `true` if connected to a server, `false` otherwise.
     def connected?
       !socket.nil? && !socket.closed?
     end
-    
+
     def handshake; end
     def cleanup; end
-    
+
     def protobuf_handshake(type, **attrs)
       send_message PB::ConnectionRequest.new(type: type, **attrs)
       resp = receive_message PB::ConnectionResponse
       raise(ConnectionError, "#{resp.status} -- #{resp.message}") unless resp.status == :OK
       resp
     end
-    
+
     def send(data)
       @socket.send(data, 0)
     end
     def send_message(msg)
       send Encoder.encode_message_with_size(msg)
     end
-    
+
     def recv(maxlen = 1)
       maxlen == 0 ? "" : @socket.read(maxlen)
     end
@@ -88,7 +88,7 @@ module KRPC
   # TCP connection for sending RPC calls and retrieving its results.
   class RPCConnection < Connection
     attr_reader :name, :client_id
-    
+
     def initialize(name = Client::DEFAULT_NAME, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_RPC_PORT)
       super host, port
       @name = name
@@ -99,7 +99,7 @@ module KRPC
       resp = protobuf_handshake(:RPC, client_name: name)
       @client_id = resp.client_identifier
     end
-    
+
     def cleanup
       @client_id = nil
     end
@@ -109,17 +109,17 @@ module KRPC
   # TCP connection for streaming.
   class StreamConnection < Connection
     attr_reader :rpc_connection
-    
+
     def initialize(rpc_connection, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_STREAM_PORT)
       super host, port
       @rpc_connection = rpc_connection
     end
-    
+
     # Perform handshake with kRPC server, sending `client_id` retrieved from `rpc_connection`.
     def handshake
-      raise(ConnectionError, "RPC connection must obtain client_id before stream connection can perform valid handshake - closing stream connection") if rpc_connection.client_id.nil? 
+      raise(ConnectionError, "RPC connection must obtain client_id before stream connection can perform valid handshake - closing stream connection") if rpc_connection.client_id.nil?
       protobuf_handshake(:STREAM, client_identifier: rpc_connection.client_id)
     end
   end
-  
+
 end

data/lib/krpc/core_extensions.rb

@@ -3,7 +3,7 @@ class Module
   def class_name
     name.rpartition("::").last
   end
-  
+
   def const_get_or_create(module_name, value = nil, &block)
     return const_get(module_name) if const_defined?(module_name, false)
     value = block.call if block_given?
@@ -26,9 +26,9 @@ class String
   end
 
   def integer?
-    Integer(self) != nil rescue false 
+    Integer(self) != nil rescue false
   end
-  
+
   def numeric?
     Float(self) != nil rescue false
   end

data/lib/krpc/decoder.rb

@@ -4,7 +4,7 @@ require 'set'
 module KRPC
   module Decoder
     class << self
-    
+
       # Given a type object, and serialized data, decode the ruby value/object
       def decode(data, type, client)
         if type.is_a?(Types::MessageType) then type.ruby_type.decode(data)
@@ -33,12 +33,12 @@ module KRPC
         else raise(RuntimeError, "Cannot decode type #{type} from data: #{data}")
         end
       end
-      
+
       def decode_value(data, type)
         type_string = type.is_a?(String) ? type : type.protobuf_type.code.to_s.downcase
-        ProtobufUtils::Decoder.decode(data, type_string) 
+        ProtobufUtils::Decoder.decode(data, type_string)
       end
-      
+
     end
   end
 end

data/lib/krpc/doc.rb

@@ -7,7 +7,7 @@ module KRPC
     @docstr_infos = {}
     @procedure_docstr_infos = {}
     class << self
-      
+
       def docstring_for_method(method_owner, method_name, is_print_xmldoc_summary = true)
         is_static, class_cls = method_owner.class == Class ? [true, method_owner] : [false, method_owner.class]
         service_module_name, class_name = ruby_class_to_pb_module_class_pair(class_cls)
@@ -16,10 +16,10 @@ module KRPC
           construct_docstring(*@docstr_infos[key], true, is_static, is_print_xmldoc_summary)
         else
           "No docstring for #{class_cls.name}#{calc_separator(is_static)}#{method_name.to_s} method" +
-            (method_owner.respond_to?(method_name) ? "" : "\nThere is no such method -- maybe a typo")
+            (method_owner.respond_to?(method_name) ? "" : "\nThere is no such method -- maybe a typo?")
         end
       end
-      
+
       def docstring_for_procedure(service_name, procedure_name, is_print_xmldoc_summary = true)
         key = [service_name, procedure_name].hash
         if @procedure_docstr_infos.has_key? key
@@ -40,30 +40,30 @@ module KRPC
           @docstr_infos[key2] = val
         end
       end
-      
+
       def add_special_docstring_info(key, value)
         @docstr_infos[key] = value
       end
-      
+
       private #----------------------------------
-      
+
       def ruby_class_to_pb_module_class_pair(ruby_class)
         return ["", Client.class_name] if ruby_class == Client
         rest, _, pb_class_name = ruby_class.name.rpartition("::")
         _, _, pb_service_name = rest.rpartition("::")
         [pb_service_name, pb_class_name]
       end
-      
+
       def calc_separator(is_static)
         is_static ? '.' : '#'
       end
-      
+
       def construct_docstring(namespace, separator, name, param_names, param_types, param_default, return_type, xmldoc, is_hide_this_param, is_prepend_client_param,  is_print_xmldoc_summary)
         xmldoc = Nokogiri::XML(xmldoc)
         xmldoc_summary = xmlElements2str(xmldoc.xpath("doc/summary").children, :light_blue, :light_green, :light_red)
 
         xmldoc_returns = xmlElements2str(xmldoc.xpath("doc/returns").children, :blue, :green, :light_red)
-        xmldoc_returns = "- ".blue + xmldoc_returns unless xmldoc_returns.empty? 
+        xmldoc_returns = "- ".blue + xmldoc_returns unless xmldoc_returns.empty?
 
         xmldoc_params = {}
         xmldoc.xpath("doc/param").each do |e|
@@ -76,10 +76,10 @@ module KRPC
             end
           end
         end
-        
+
         param_infos = param_names.zip(param_types.map{|x| type2str(x)}, param_default)
         param_infos.shift if is_hide_this_param && param_names[0] == "this"
-        param_infos.unshift ["client", "Client", :no_default_value] if is_prepend_client_param 
+        param_infos.unshift ["client", "Client", :no_default_value] if is_prepend_client_param
         if param_infos.empty?
           params = ""
         else
@@ -92,14 +92,14 @@ module KRPC
         "#{namespace.cyan}#{separator.cyan}#{name.bold}(#{params}) :#{type2str(return_type).light_red} #{xmldoc_returns}" \
           + (is_print_xmldoc_summary ? "\n\n#{xmldoc_summary}" : "")
       end
-      
+
       def type2str(type)
         return "nil" if type.nil?
         return type.class_name if type.class == Class
         rt = type.ruby_type
         if type.is_a?(Types::EnumType) then "Enum" + rt.keys.to_s
         elsif type.is_a?(Types::ListType) ||
-              type.is_a?(Types::SetType) 
+              type.is_a?(Types::SetType)
           "#{rt.class_name}[#{type2str(type.value_type)}]"
         elsif type.is_a?(Types::DictionaryType)
           %Q{#{rt.class_name}[#{type2str(type.key_type)} => #{type2str(type.value_type)}]}
@@ -107,7 +107,7 @@ module KRPC
           %Q{#{rt.class_name}[#{type.value_types.map{|x| type2str(x)}.join(", ")}]}
         else rt.class_name end
       end
-        
+
       def xmlElements2str(elements, main_color, paramref_color, value_color, error_color = :red)
         elements.map do |elem|
           if elem.is_a?(Nokogiri::XML::Text)
@@ -138,13 +138,13 @@ module KRPC
                   elem.text.gsub("null","nil").colorize(value_color)
                 else elem.to_s.colorize(error_color)
               end
-            rescue RuntimeException => exc
+            rescue RuntimeException
               elem.to_s.colorize(error_color)
             end
           end
         end.join.gsub("\n"," ").gsub("!n!","\n").squeeze(' ').strip.gsub("!s!"," ")
       end
-      
+
       def is_method_defined(path_array)
         method_name = path_array[-1].underscore
         begin
@@ -154,23 +154,18 @@ module KRPC
           false
         end
       end
-      
+
     end
-    
-    
+
+
     module SuffixMethods
       DOCSTRING_SUFFIX = "_doc"
       DOCSTRING_SUFFIX_REGEX = /^(.+)(?:#{DOCSTRING_SUFFIX}(=)?)$/
-      
+
       def self.included(base)
-        base.extend self
-        class << base
-          def krpc_name
-            class_name
-          end
-        end
+        base.extend self, ClassMethods
       end
-      
+
       def method_missing(method, *args, &block)
         if DOCSTRING_SUFFIX_REGEX =~ method.to_s
           documented_method_name = $1 + $2.to_s
@@ -180,14 +175,20 @@ module KRPC
         end
         super
       end
-      
+
       def respond_to_missing?(method, *)
         if DOCSTRING_SUFFIX_REGEX =~ method.to_s
           return true if respond_to? ($1 + $2.to_s).to_sym
         end
         super
       end
+
+      module ClassMethods
+        def krpc_name
+          class_name
+        end
+      end
     end
-    
+
   end
 end