krpc 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02d7e464d0718d9f223f97b336d4cc861f6bb975
-  data.tar.gz: a89bd9cfb911f51e9b2ee1979338f0a1a260289b
+  metadata.gz: ef6917b47511f404073511fc327657a34d46967f
+  data.tar.gz: 06ef229097a2524042524b155ff38c3ff110f5ee
 SHA512:
-  metadata.gz: 058ee29c70d2cbe13a2cbf9d1016a188d18572f565c142ace38dc626e2efb62172dbf2be128000bcd61ce43cb09043a3f70cab404d8879ebeded19c0749270a7
-  data.tar.gz: ae5432d952cb0aad317c064cd85487df95a6f85dbfa76db1dbf981a0527b241eb660df55de05f985eba42a5d5cc4a98511aba474dbf4c8a11f2ebf30b87fe4a9
+  metadata.gz: cf70656dc94287f0d52f00af03d338258779612a56e09957a0b02e740155477baeb0c508e95dcff5dd5d3ebeb5e31949a2eb72b1e2e0296abcf098638ba5b176
+  data.tar.gz: 1e54734369a2c4f72add79e9325e71698f19ba3409bb84747f9351b8df9c72a020be5d1950b516ba6ebe5984351724774e612717d77a65eaa8b5c3555d3fa4e8

data/README.md

@@ -10,6 +10,8 @@ Installation
 
     gem install krpc
 
+or install the latest pre-release version (if [available](https://rubygems.org/gems/krpc/versions)): `gem install krpc --pre`
+
 Basic usage
 -------
 
@@ -94,7 +96,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
 ```
 
@@ -132,7 +134,7 @@ pos_stream.remove #note: dead code - just as an example
 
 Want to know more?
 -------
-* Read official **kRPC documentation** at http://krpc.github.io/krpc/, with many great [tutorials and examples](http://krpc.github.io/krpc/tutorials.html).
-* Refer to **kRPC-rb documentation** at http://tewu.github.io/krpc-rb/doc
+* Read official **kRPC documentation** at https://krpc.github.io/krpc, with many great [tutorials and examples](https://krpc.github.io/krpc/tutorials.html).
+* Refer to **kRPC-rb documentation** at https://tewu.github.io/krpc-rb-apidocs
 * See official **kRPC forum thread** at http://forum.kerbalspaceprogram.com/threads/69313
 

data/krpc.gemspec

@@ -9,28 +9,27 @@ Gem::Specification.new do |s|
   s.version       = KRPC::VERSION
   s.authors       = ["Tomasz Więch"]
   s.email         = ["tewu.dev@gmail.com"]
-  
+
   s.summary       = "Client library for kRPC"
   s.description   = "kRPC-rb is a Ruby client library for kRPC, a Kerbal Space Program mod that allows you to control KSP from external scripts running outside of the game."
   s.homepage      = "https://github.com/TeWu/krpc-rb"
   s.license       = "GPL-3.0"
-  
-  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|bin/TestServer)/}) || f.start_with?('.') }
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|bin)/|Rakefile|CHANGELOG}) || f.start_with?('.') }
   s.require_paths = ["lib"]
   s.extra_rdoc_files = ["README.md"]
   s.rdoc_options << "--markup" << "markdown" <<
-                    "--format" << "hanna" <<
                     "--title"  << "kRPC-rb API Docs" <<
                     "--main"   << "README.md"
-  
+
   s.required_ruby_version = ">= 2.1.0"
 
-  s.add_runtime_dependency "google-protobuf", "~> 3.0.0.alpha.5"
-  s.add_runtime_dependency "colorize", "~> 0.7"
-  s.add_runtime_dependency "nokogiri", "~> 1.6"
-  s.add_runtime_dependency "hanna-nouveau", "~> 0.4"
-  s.add_development_dependency "bundler", "~> 1.11"
+  s.add_runtime_dependency "google-protobuf", "~> 3.3"
+  s.add_runtime_dependency "colorize", "~> 0.8"
+  s.add_runtime_dependency "nokogiri", "~> 1.8"
+  s.add_development_dependency "bundler", "~> 1.15"
   s.add_development_dependency "pry", "~> 0.10"
-  s.add_development_dependency "rspec", "~> 3.4"
-  s.add_development_dependency "rake", "~> 11.1"
+  s.add_development_dependency "rspec", "~> 3.6"
+  s.add_development_dependency "rake", "~> 12.0"
+  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/attributes.rb

@@ -8,73 +8,73 @@ module KRPC
         attrs.any?{|a| a.start_with? prefix }
       end
       alias_method :asw?, :is_any_start_with?
-      
+
       def is_a_property_accessor(attrs) asw?(attrs,"Property.")  end
       def is_a_property_getter(attrs) asw?(attrs,"Property.Get(") end
       def is_a_property_setter(attrs) asw?(attrs,"Property.Set(") end
       def is_a_class_method_or_property_accessor(attrs) asw?(attrs,"Class.") end
       def is_a_class_method(attrs) asw?(attrs,"Class.Method(") end
-      def is_a_class_static_method(attrs) asw?(attrs,"Class.StaticMethod(") end    
+      def is_a_class_static_method(attrs) asw?(attrs,"Class.StaticMethod(") end
       def is_a_class_property_accessor(attrs) asw?(attrs,"Class.Property.") end
       def is_a_class_property_getter(attrs) asw?(attrs,"Class.Property.Get(") end
       def is_a_class_property_setter(attrs) asw?(attrs,"Class.Property.Set(") end
-      
+
       def get_service_name(attrs)
         if is_a_class_method(attrs) || is_a_class_static_method(attrs)
-          attrs.each do |a| 
+          attrs.each do |a|
             return $1 if /^Class\.(?:Static)?Method\(([^,\.]+)\.[^,]+,[^,]+\)$/ =~ a
           end
         elsif is_a_class_property_accessor(attrs)
-          attrs.each do |a| 
+          attrs.each do |a|
             return $1 if /^Class\.Property.(?:Get|Set)\(([^,\.]+)\.[^,]+,[^,]+\)$/ =~ a
           end
         end
         raise(ValueError, "Procedure attributes are not a class method or property accessor")
       end
-      
+
       def get_class_name(attrs)
         if is_a_class_method(attrs) || is_a_class_static_method(attrs)
-          attrs.each do |a| 
+          attrs.each do |a|
             return $1 if /^Class\.(?:Static)?Method\([^,\.]+\.([^,\.]+),[^,]+\)$/ =~ a
           end
         elsif is_a_class_property_accessor(attrs)
-          attrs.each do |a| 
+          attrs.each do |a|
             return $1 if /^Class\.Property.(?:Get|Set)\([^,\.]+\.([^,]+),[^,]+\)$/ =~ a
           end
         end
         raise(ValueError, "Procedure attributes are not a class method or property accessor")
       end
-      
+
       def get_property_name(attrs)
         if is_a_property_accessor(attrs)
-          attrs.each do |a| 
+          attrs.each do |a|
             return $1 if /^Property\.(?:Get|Set)\((.+)\)$/ =~ a
           end
         end
         raise(ValueError, "Procedure attributes are not a property accessor")
       end
-      
+
       def get_class_method_or_property_name(attrs)
         if is_a_class_method(attrs) || is_a_class_static_method(attrs) || is_a_class_property_accessor(attrs)
-          attrs.each do |a| 
+          attrs.each do |a|
             return $1 if /^Class\.(?:(?:Static)?Method|Property\.(?:Get|Set))\([^,]+,([^,]+)\)$/ =~ a
           end
         end
         raise(ValueError, "Procedure attributes are not a class method or class property accessor")
       end
-      
+
       def get_parameter_type_attrs(pos, attrs)
-        attrs.map do |a| 
+        attrs.map do |a|
           (/^ParameterType\(#{pos}\).(.+)$/ =~ a) ? $1 : nil
         end.compact
       end
-      
+
       def get_return_type_attrs(attrs)
-        attrs.map do |a| 
+        attrs.map do |a|
           (/^ReturnType.(.+)$/ =~ a) ? $1 : nil
         end.compact
       end
-      
+
     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 services API (with
   # Client#generate_services_api! call), RPCs can be also made using
   # `client.service_name.procedure_name(parameter, ...)`
@@ -32,9 +32,9 @@ module KRPC
 
     include Doc::SuffixMethods
 
-    attr_reader :name, :rpc_connection, :stream_connection, :streams_manager, :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 (up to 32 bytes of UTF-8 encoded text).
     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
@@ -42,13 +42,13 @@ module KRPC
       @stream_connection = StreamConnection.new(rpc_connection, host, stream_port)
       @streams_manager = Streaming::StreamsManager.new(self)
       @services = {}
-      @krpc = Services::KRPC.new(self)
-      Doc.add_docstring_info(false, self.class, "krpc", return_type: @krpc.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.</summary></doc>")
+      @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 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 services API and return `self`. Shorthand for calling 
-    # Client#connect and Client#generate_services_api! subsequently. If the block is given, then 
+
+    # Connect to a kRPC server, generate services API and return `self`. Shorthand for calling
+    # 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 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, that form API for 
+    # 3. Those classes in turn are filled with dynamically created methods, that form 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,10 +108,9 @@ module KRPC
     def generate_services_api!
       return self if services_api_generated?
       raise(Exception, "Can't generate services API while not connected to server -- call Client#connect! to connect to server and generate services API in one call") if not connected?
-      
-      resp = krpc.get_services
+
+      resp = core.get_services
       resp.services.each do |service_msg|
-        next if service_msg.name == "KRPC"
         service_class = Services.create_service(service_msg)
         method_name = service_class.class_name.underscore
         self.class.instance_eval do
@@ -123,12 +122,12 @@ module KRPC
       end
       self
     end
-    
+
     # Returns `true` if 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)
@@ -159,11 +158,11 @@ module KRPC
     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
-      
+
       req_args = param_names_symbols.map.with_index do |name, i|
         is_kwarg = kwargs.has_key? name
         kwargs_remaining -= 1 if is_kwarg
@@ -189,7 +188,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
       req_args
     end
@@ -198,16 +197,16 @@ module KRPC
       req = build_request(service, procedure, args, kwargs, param_names, param_types, param_default)
       rpc_connection.send Encoder.encode_request(req)
     end
-    
+
     def receive_response
       resp_length = rpc_connection.recv_varint
       resp_data = rpc_connection.recv resp_length
       resp = PB::Response.decode(resp_data)
     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,20 +40,20 @@ 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 send(msg) @socket.send(msg, 0) end
     def recv(maxlen = 1)
       maxlen == 0 ? "" : @socket.read(maxlen)
     end
-    
+
     def recv_varint
       int_val = 0
       shift = 0
@@ -65,9 +65,9 @@ module KRPC
         raise(RuntimeError, "too many bytes when decoding varint") if shift >= 64
       end
     end
-    
+
     protected #----------------------------------
-    
+
     def trim_fill(str, len, fill_char = "\x00")
       str = str.encode("UTF-8")[0, len]
       str + fill_char*(len-str.length)
@@ -78,7 +78,7 @@ module KRPC
   # TCP connection for sending RPC calls and retrieving it's results.
   class RPCConnection < Connection
     attr_reader :name, :client_id
-    
+
     def initialize(name, host = DEFAULT_SERVER_HOST, port = DEFAULT_SERVER_RPC_PORT)
       super host, port
       @name = name
@@ -90,7 +90,7 @@ module KRPC
       send trim_fill(name, Encoder::NAME_LENGTH)
       @client_id = recv Decoder::GUID_LENGTH
     end
-    
+
     # Clean up - sets `@client_id` to `nil`.
     def cleanup
       @client_id = nil
@@ -101,20 +101,20 @@ 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?
       send Encoder::STREAM_HELLO_MESSAGE
       send rpc_connection.client_id
       resp = recv Decoder::OK_LENGTH
       raise ConnectionError unless resp == Decoder::OK_MESSAGE
     end
   end
-  
+
 end