krpc 0.3.2 → 0.4.0.beta1

data/lib/krpc/krpc.pb.rb

@@ -4,7 +4,30 @@
 require 'google/protobuf'
 
 Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "krpc.schema.ConnectionRequest" do
+    optional :type, :enum, 1, "krpc.schema.ConnectionRequest.Type"
+    optional :client_name, :string, 2
+    optional :client_identifier, :bytes, 3
+  end
+  add_enum "krpc.schema.ConnectionRequest.Type" do
+    value :RPC, 0
+    value :STREAM, 1
+  end
+  add_message "krpc.schema.ConnectionResponse" do
+    optional :status, :enum, 1, "krpc.schema.ConnectionResponse.Status"
+    optional :message, :string, 2
+    optional :client_identifier, :bytes, 3
+  end
+  add_enum "krpc.schema.ConnectionResponse.Status" do
+    value :OK, 0
+    value :MALFORMED_MESSAGE, 1
+    value :TIMEOUT, 2
+    value :WRONG_TYPE, 3
+  end
   add_message "krpc.schema.Request" do
+    repeated :calls, :message, 1, "krpc.schema.ProcedureCall"
+  end
+  add_message "krpc.schema.ProcedureCall" do
     optional :service, :string, 1
     optional :procedure, :string, 2
     repeated :arguments, :message, 3, "krpc.schema.Argument"
@@ -14,18 +37,19 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :value, :bytes, 2
   end
   add_message "krpc.schema.Response" do
-    optional :time, :double, 1
-    optional :has_error, :bool, 2
-    optional :error, :string, 3
-    optional :has_return_value, :bool, 4
-    optional :return_value, :bytes, 5
+    optional :error, :string, 1
+    repeated :results, :message, 2, "krpc.schema.ProcedureResult"
   end
-  add_message "krpc.schema.StreamMessage" do
-    repeated :responses, :message, 1, "krpc.schema.StreamResponse"
+  add_message "krpc.schema.ProcedureResult" do
+    optional :error, :string, 1
+    optional :value, :bytes, 2
   end
-  add_message "krpc.schema.StreamResponse" do
-    optional :id, :uint32, 1
-    optional :response, :message, 2, "krpc.schema.Response"
+  add_message "krpc.schema.StreamUpdate" do
+    repeated :results, :message, 1, "krpc.schema.StreamResult"
+  end
+  add_message "krpc.schema.StreamResult" do
+    optional :id, :uint64, 1
+    optional :result, :message, 2, "krpc.schema.ProcedureResult"
   end
   add_message "krpc.schema.Services" do
     repeated :services, :message, 1, "krpc.schema.Service"
@@ -40,16 +64,13 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
   add_message "krpc.schema.Procedure" do
     optional :name, :string, 1
     repeated :parameters, :message, 2, "krpc.schema.Parameter"
-    optional :has_return_type, :bool, 3
-    optional :return_type, :string, 4
-    repeated :attributes, :string, 5
-    optional :documentation, :string, 6
+    optional :return_type, :message, 3, "krpc.schema.Type"
+    optional :documentation, :string, 4
   end
   add_message "krpc.schema.Parameter" do
     optional :name, :string, 1
-    optional :type, :string, 2
-    optional :has_default_value, :bool, 3
-    optional :default_value, :bytes, 4
+    optional :type, :message, 2, "krpc.schema.Type"
+    optional :default_value, :bytes, 3
   end
   add_message "krpc.schema.Class" do
     optional :name, :string, 1
@@ -65,9 +86,43 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :value, :int32, 2
     optional :documentation, :string, 3
   end
+  add_message "krpc.schema.Type" do
+    optional :code, :enum, 1, "krpc.schema.Type.TypeCode"
+    optional :service, :string, 2
+    optional :name, :string, 3
+    repeated :types, :message, 4, "krpc.schema.Type"
+  end
+  add_enum "krpc.schema.Type.TypeCode" do
+    value :NONE, 0
+    value :DOUBLE, 1
+    value :FLOAT, 2
+    value :SINT32, 3
+    value :SINT64, 4
+    value :UINT32, 5
+    value :UINT64, 6
+    value :BOOL, 7
+    value :STRING, 8
+    value :BYTES, 9
+    value :CLASS, 100
+    value :ENUMERATION, 101
+    value :PROCEDURE_CALL, 200
+    value :STREAM, 201
+    value :STATUS, 202
+    value :SERVICES, 203
+    value :TUPLE, 300
+    value :LIST, 301
+    value :SET, 302
+    value :DICTIONARY, 303
+  end
+  add_message "krpc.schema.Tuple" do
+    repeated :items, :bytes, 1
+  end
   add_message "krpc.schema.List" do
     repeated :items, :bytes, 1
   end
+  add_message "krpc.schema.Set" do
+    repeated :items, :bytes, 1
+  end
   add_message "krpc.schema.Dictionary" do
     repeated :entries, :message, 1, "krpc.schema.DictionaryEntry"
   end
@@ -75,11 +130,8 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     optional :key, :bytes, 1
     optional :value, :bytes, 2
   end
-  add_message "krpc.schema.Set" do
-    repeated :items, :bytes, 1
-  end
-  add_message "krpc.schema.Tuple" do
-    repeated :items, :bytes, 1
+  add_message "krpc.schema.Stream" do
+    optional :id, :uint64, 1
   end
   add_message "krpc.schema.Status" do
     optional :version, :string, 1
@@ -106,11 +158,17 @@ end
 
 module KRPC
   module PB
+    ConnectionRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.ConnectionRequest").msgclass
+    ConnectionRequest::Type = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.ConnectionRequest.Type").enummodule
+    ConnectionResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.ConnectionResponse").msgclass
+    ConnectionResponse::Status = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.ConnectionResponse.Status").enummodule
     Request = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Request").msgclass
+    ProcedureCall = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.ProcedureCall").msgclass
     Argument = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Argument").msgclass
     Response = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Response").msgclass
-    StreamMessage = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.StreamMessage").msgclass
-    StreamResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.StreamResponse").msgclass
+    ProcedureResult = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.ProcedureResult").msgclass
+    StreamUpdate = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.StreamUpdate").msgclass
+    StreamResult = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.StreamResult").msgclass
     Services = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Services").msgclass
     Service = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Service").msgclass
     Procedure = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Procedure").msgclass
@@ -118,11 +176,14 @@ module KRPC
     Class = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Class").msgclass
     Enumeration = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Enumeration").msgclass
     EnumerationValue = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.EnumerationValue").msgclass
+    Type = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Type").msgclass
+    Type::TypeCode = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Type.TypeCode").enummodule
+    Tuple = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Tuple").msgclass
     List = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.List").msgclass
+    Set = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Set").msgclass
     Dictionary = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Dictionary").msgclass
     DictionaryEntry = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.DictionaryEntry").msgclass
-    Set = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Set").msgclass
-    Tuple = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Tuple").msgclass
+    Stream = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Stream").msgclass
     Status = Google::Protobuf::DescriptorPool.generated_pool.lookup("krpc.schema.Status").msgclass
   end
 end

data/lib/krpc/procedure_name_parser.rb

@@ -0,0 +1,47 @@
+require 'krpc/error'
+
+module KRPC
+  module ProcedureNameParser
+
+    def self.parse(proc_name)
+      parts = proc_name.split('_')
+      name = parts[-1]
+      raise(ProcedureNameParserError, "Procedure name is empty") if proc_name.empty?
+      raise(ProcedureNameParserError, "Invalid procedure name") if parts.size > 3
+
+      case parts.size
+        when 1
+          Result.new(:plain_procedure, false, false, name, nil)
+        when 2
+          case parts[0]
+            when 'get'
+              Result.new(:service_property_getter, false, false, name, nil)
+            when 'set'
+              Result.new(:service_property_setter, true, false, name, nil)
+            else
+              Result.new(:class_method, false, true, name, parts[0])
+          end
+        when 3
+          case parts[1]
+            when 'get'
+              Result.new(:class_property_getter, false, true, name, parts[0])
+            when 'set'
+              Result.new(:class_property_setter, true, true, name, parts[0])
+            when 'static'
+              Result.new(:class_static_method, false, true, name, parts[0])
+            else
+              raise(ProcedureNameParserError, "Invalid procedure name")
+          end
+      end
+    end
+
+
+    class Result < Struct.new(:type, :setter?, :class_member?, :member_name, :class_name)
+      def class_name
+        raise(ValueError, "Procedure is not a class method or property") unless super
+        super
+      end
+    end
+
+  end
+end

data/lib/krpc/protobuf_extensions.rb

@@ -1,20 +1,41 @@
 require 'krpc/krpc.pb'
+require 'krpc/procedure_name_parser'
 
 module KRPC
   module ProtobufExtensions
+    module SafeEquals
 
-    module MessageExtensions
       def ==(other)
         super
       rescue TypeError
         false
       end
+
+    end
+    module MessageExtensions
+      include SafeEquals
+
+      def field_empty?(field)
+        val = self.send(field)
+        "" == val || [] == val || val.nil?
+      end
+
     end
+    module ProcedureExtensions
+      extend Forwardable
 
+      def info
+        @info ||= ProcedureNameParser.parse(name)
+      end
+      def_delegators :info, *ProcedureNameParser::Result.members
+
+    end
   end
 end
 
+Google::Protobuf::RepeatedField.prepend KRPC::ProtobufExtensions::SafeEquals
 KRPC::PB.constants(false).map {|const_name| KRPC::PB.const_get(const_name,true)}.each do |msgclass|
   msgclass.prepend KRPC::ProtobufExtensions::MessageExtensions
 end
+KRPC::PB::Procedure.prepend KRPC::ProtobufExtensions::ProcedureExtensions
 

data/lib/krpc/protobuf_utils.rb

@@ -2,28 +2,21 @@ require 'krpc/krpc.pb'
 
 module KRPC
   module ProtobufUtils
-    class << self
-      def create_PB_to_PB_message_class_hash(package)
-        protobuf_module = Kernel.const_get(package.gsub(".","::") + "::PB")
-        protobuf_module.constants.map do |name|
-          [package + "." + name.to_s, protobuf_module.const_get(name,false)]
-        end.to_h
-      end
-    end
-
     module Decoder
       class << self
+      
         def decode(bytes, type)
           meth_name = "decode_" + type
           raise RuntimeError.new("Unsupported type #{type}") unless respond_to?(meth_name)
           send(meth_name, bytes)
         end
 
-        # based on: https://developers.google.com/protocol-buffers/docs/encoding#varints  &  http://www.rubydoc.info/gems/ruby-protocol-buffers/1.0.1/ProtocolBuffers/Varint#decode-class_method  &  https://github.com/google/protobuf/blob/master/python/google/protobuf/internal/decoder.py#L136
+        # based on: https://developers.google.com/protocol-buffers/docs/encoding#varints  &  http://www.rubydoc.info/gems/ruby-protocol-buffers/1.0.1/ProtocolBuffers/Varint#decode-class_method  &  https://github.com/google/protobuf/blob/master/python/google/protobuf/internal/decoder.py#L136  
         def decode_varint(bytes)
           decode_varint_pos(bytes)[0]
         end
         def decode_varint_pos(bytes)
+          raise(RuntimeError, "can't decode varint from empty byte buffer") if bytes.empty?
           pos = 0
           result = 0
           shift = 0
@@ -36,17 +29,16 @@ module KRPC
             raise(RuntimeError, "too many bytes when decoding varint") if shift >= 64
           end
         end
-        def decode_signed_varint(bytes)
-          result = decode_varint(bytes)
-          result -= (1 << 64) if result > 0x7fffffffffffffff
-          result
+        def decode_zigzaged_varint(bytes)
+          zigzaged = decode_varint(bytes)
+          (zigzaged >> 1) ^ -(zigzaged & 1)
         end
-
-        alias_method :decode_int32, :decode_signed_varint
-        alias_method :decode_int64, :decode_signed_varint
+        
+        alias_method :decode_sint32, :decode_zigzaged_varint
+        alias_method :decode_sint64, :decode_zigzaged_varint
         alias_method :decode_uint32, :decode_varint
         alias_method :decode_uint64, :decode_varint
-
+        
         # based on: https://github.com/ruby-protobuf/protobuf/search?q=pack
         def decode_float(bytes)
           bytes.unpack('e').first
@@ -65,18 +57,19 @@ module KRPC
           size, pos = decode_varint_pos(bytes)
           bytes[pos..(pos+size)].bytes
         end
-
+        
       end
     end
-
+    
     module Encoder
       class << self
+      
         def encode(value, type)
           meth_name = "encode_" + type
           raise(RuntimeError, "Unsupported type #{type}") unless respond_to?(meth_name)
           send(meth_name, value)
         end
-
+        
         # based on: http://www.rubydoc.info/gems/ruby-protocol-buffers/1.0.1/ProtocolBuffers/Varint#decode-class_method  &  https://github.com/google/protobuf/blob/master/python/google/protobuf/internal/encoder.py#L390
         def encode_varint(value)
           return [value].pack('C') if value < 0b1000_0000
@@ -91,20 +84,24 @@ module KRPC
             end
           end
         end
-        def encode_signed_varint(value)
-          value += (1 << 64) if value < 0
-          encode_varint(value)
-        end
         def encode_nonnegative_varint(value)
           raise(RangeError, "Value must be non-negative, got #{value}") if value < 0
           encode_varint(value)
         end
-
-        alias_method :encode_int32, :encode_signed_varint
-        alias_method :encode_int64, :encode_signed_varint
+        def encode_zigzaged_varint_32(value)
+          zigzaged = (value << 1) ^ (value >> 31)
+          encode_varint(zigzaged)
+        end
+        def encode_zigzaged_varint_64(value)
+          zigzaged = (value << 1) ^ (value >> 63)
+          encode_varint(zigzaged)
+        end
+        
+        alias_method :encode_sint32, :encode_zigzaged_varint_32
+        alias_method :encode_sint64, :encode_zigzaged_varint_64
         alias_method :encode_uint32, :encode_nonnegative_varint
         alias_method :encode_uint64, :encode_nonnegative_varint
-
+        
         def encode_float(value)
           [value].pack('e')
         end
@@ -122,9 +119,9 @@ module KRPC
           size = encode_varint(value.size)
           size + value.map(&:chr).join.b
         end
-
+        
       end
     end
-
+    
   end
 end

data/lib/krpc/service.rb

@@ -1,81 +1,60 @@
 require 'krpc/gen'
-require 'krpc/attributes'
-require 'krpc/encoder'
-require 'krpc/types'
 require 'krpc/doc'
 require 'krpc/streaming'
 
 module KRPC
   module Services
     class << self
-
+    
       # Generate classes and methods for the service - see documentation for Client#generate_services_api!
       def create_service(service_msg)
         service_name = service_msg.name
-
+        
         # Create service class
         service_class = Class.new(ServiceBase)
         const_set(service_name, service_class)
-
+        
         # Create service' classes
-        service_msg.classes.map(&:name).each do |sc_name|
-          TypeStore["Class(#{service_name}.#{sc_name})"]
+        class_types_by_name = Hash.new do |h,k|
+          TypeStore[PB::Type.new(code: :CLASS, service: service_name, name: k)]
         end
-
+        service_msg.classes.map(&:name).each {|cn| class_types_by_name[cn] }
+        
         # Create service' enums
         service_msg.enumerations.each do |enum|
-          enum_type = TypeStore["Enum(#{service_name}.#{enum.name})"]
+          enum_type = TypeStore[PB::Type.new(code: :ENUMERATION, service: service_name, name: enum.name)]
           enum_type.set_values(enum.values)
         end
-
+        
         # Create service' procedures
         service_msg.procedures.each do |proc|
-          if Attributes.is_a_class_method_or_property_accessor(proc.attributes)
-            class_name  = Attributes.get_class_name(proc.attributes)
-            class_cls = TypeStore["Class(#{service_name}.#{class_name})"].ruby_type
-            method_name = Attributes.get_class_method_or_property_name(proc.attributes)
-            if Attributes.is_a_class_property_accessor(proc.attributes)  # service' class property
-              if Attributes.is_a_class_property_getter(proc.attributes)
-                Gen.add_rpc_method(class_cls, method_name, service_name, proc, :prepend_self_to_args)
-              else
-                Gen.add_rpc_method(class_cls, method_name + '=', service_name, proc, :prepend_self_to_args, :no_stream)
-              end
-            elsif Attributes.is_a_class_method(proc.attributes)  # service' class method
-              Gen.add_rpc_method(class_cls, method_name, service_name, proc, :prepend_self_to_args)
-            else  # service' static class method
-              Gen.add_rpc_method(class_cls, method_name, service_name, proc, :static)
-            end
-          elsif Attributes.is_a_property_accessor(proc.attributes)  # service' property
-            property_name = Attributes.get_property_name(proc.attributes)
-            if Attributes.is_a_property_getter(proc.attributes)
-              Gen.add_rpc_method(service_class, property_name, service_name, proc)
-            elsif Attributes.is_a_property_setter(proc.attributes)
-              Gen.add_rpc_method(service_class, property_name + '=', service_name, proc, :no_stream)
-            end
-          else  # plain procedure = method available to service class and its instance
-            Gen.add_rpc_method(service_class, proc.name, service_name, proc, :static)
-          end
+          cls = if proc.class_member?
+                  class_types_by_name[proc.class_name].ruby_type
+                else
+                  service_class
+                end
+          Gen.add_rpc_method(cls, service_name, proc)
         end
-
+        
         # Return service class
         service_class
       end
-
+      
     end
-
+    
     ##
     # Base class for service objects, created at runtime using information received from the server.
     class ServiceBase
       include Doc::SuffixMethods
       include Streaming::StreamConstructors
-
+      
       attr_reader :client
-
+  
       def initialize(client)
         @client = client
       end
     end
-
+    
     ##
     # Hardcoded version of `krpc` service - The core kRPC service, e.g. for querying for the available services.
     class Core < ServiceBase
@@ -85,7 +64,7 @@ module KRPC
         super(client)
         unless respond_to? :get_status
           # Generate enumerations
-          TypeStore['Enum(Core.GameScene)'].set_values(
+          TypeStore[PB::Type.new(code: :ENUMERATION, service: 'Core', name: 'GameScene')].set_values(
             Encoder.hash_to_enumeration_values(
               space_center: 0, flight: 1, tracking_station: 2, editor_vab: 3, editor_sph: 4
             )
@@ -94,33 +73,31 @@ module KRPC
           # Generate procedures
           opts = {doc_service_name: 'Core'}
 
-          include_rpc_method 'get_status', 'KRPC', 'GetStatus',
-                             return_type: 'KRPC.Status',
+          include_rpc_method 'KRPC', 'GetStatus',
+                             return_type: PB::Type.new(code: :STATUS),
                              xmldoc: "<doc><summary>Gets a status message from the server containing information including the server’s version string and performance statistics.</summary></doc>",
-                             switches: [:static], options: opts
-          include_rpc_method 'get_services', 'KRPC', 'GetServices',
-                             return_type: 'KRPC.Services',
-                             xmldoc: "<doc><summary>Gets available services and procedures.</summary></doc>",
-                             switches: [:static, :no_stream], options: opts
-          include_rpc_method 'add_stream', 'KRPC', 'AddStream',
-                             params: [PB::Parameter.new(name: 'request', type: 'KRPC.Request')],
-                             return_type: 'uint32',
-                             xmldoc: "<doc><summary>Add a streaming request. Returns it's identifier.</summary></doc>",
-                             switches: [:static, :no_stream], options: opts
-          include_rpc_method 'remove_stream', 'KRPC', 'RemoveStream',
-                             params: [PB::Parameter.new(name: 'id', type: 'uint32')],
-                             xmldoc: "<doc><summary>Remove a streaming request</summary></doc>",
-                             switches: [:static, :no_stream], options: opts
-          include_rpc_method 'clients', 'KRPC', 'get_Clients',
-                             return_type: 'KRPC.List',
-                             attributes: ['Property.Get(Clients)', 'ReturnType.List(Tuple(bytes,string,string))'],
+                             **opts
+          include_rpc_method 'KRPC', 'GetServices',
+                             return_type: PB::Type.new(code: :SERVICES),
+                             xmldoc: "<doc><summary>Returns information on all services, procedures, classes, properties etc. provided by the server.\nCan be used by client libraries to automatically create functionality such as stubs.</summary></doc>",
+                             **opts
+          include_rpc_method 'KRPC', 'AddStream',
+                             params: [PB::Parameter.new(name: 'call', type: PB::Type.new(code: :PROCEDURE_CALL))],
+                             return_type: PB::Type.new(code: :STREAM),
+                             xmldoc: "<doc><summary>Add a streaming request and return its identifier.</summary></doc>",
+                             **opts
+          include_rpc_method 'KRPC', 'RemoveStream',
+                             params: [PB::Parameter.new(name: 'id', type: PB::Type.new(code: :UINT64))],
+                             xmldoc: "<doc><summary>Remove a streaming request.</summary></doc>",
+                             **opts
+          include_rpc_method 'KRPC', 'get_Clients',
+                             return_type: PB::Type.new(code: :LIST, types: [PB::Type.new(code: :TUPLE, types: [PB::Type.new(code: :BYTES), PB::Type.new(code: :STRING), PB::Type.new(code: :STRING)])]),
                              xmldoc: "<doc><summary>A list of RPC clients that are currently connected to the server.\nEach entry in the list is a clients identifier, name and address.</summary></doc>",
-                             switches: [:static], options: opts
-          include_rpc_method 'current_game_scene', 'KRPC', 'get_CurrentGameScene',
-                             return_type: 'int32',
-                             attributes: ['Property.Get(CurrentGameScene)', 'ReturnType.Enum(Core.GameScene)'],
+                             **opts
+          include_rpc_method 'KRPC', 'get_CurrentGameScene',
+                             return_type: PB::Type.new(code: :ENUMERATION, service: 'Core', name: 'GameScene'),
                              xmldoc: "<doc><summary>Get the current game scene.</summary></doc>",
-                             switches: [:static], options: opts
+                             **opts
         end
       end
     end